全局唯一ID服务化方案

	timestamp_bits   = 42  // 时间戳位数
	process_id_bits  = 9   // 进程ID位数
	sequence_id_bits = 12  // 序列号ID位数

<timestamp_bits:42bit><process_id_bits:9bit><sequence_id_bits:12bit>

const (
	twepoch            = 1596364434706 // begin time 2020-08-02 18:33:54
	timestamp_bits     = 42            // 时间戳占 42 位, 如果需要表示时间更久，可延长位数
	datacenter_id_bits = 3             // 数据中心 id， 占 3 位，可表示 8 个数据中心
	process_id_bits    = 6             // 进程id(可理解为机器id), 占 6位，可表示 64 台机器
	sequence_id_bits   = 12            // 序列号，每次新增都自增 1
	max_timestamp      = 1 << timestamp_bits
	max_datacenter_id  = 1 << datacenter_id_bits
	max_process_id     = 1 << process_id_bits
	max_sequence_id    = 1 << sequence_id_bits
)

func make_snowflake(timestamp_ms int64, process_id int64, sequence_id int64) int64 {
	snowflakeid := ((timestamp_ms - twepoch) % max_timestamp) << process_id_bits << sequence_id_bits
	snowflakeid += (process_id % max_process_id) << sequence_id_bits
	snowflakeid += sequence_id % max_sequence_id
	return snowflakeid
}

func Init() {
	snowflakeetcd.Dialog()
	cnf := settings.Etcd()
	snowflakeetcd.Setup(cnf.Hosts)
	quesNameSpace := getQuestionSnowflakeNameSpace()
	questionSnowflake = snowflakeetcd.GetGenerator(quesNameSpace)
}

/_snowflake_/nodes/<自定义>/1
<node_path>/<namespace>.<env>/<pid>

func (sf *SnowFlake) gen() int64 {
	sf.lock.Lock()
	defer sf.lock.Unlock()
	for {
		ts := make_timestamp()
		seq := sf.getSequnce()
		if ts == sf.last_ts && seq <= sf.last_seq {
			time.Sleep(1 * time.Millisecond)
		} else {
			sid := make_snowflake(ts, sf.process_id, seq)
			sf.last_ts = ts
			sf.last_seq = seq
			return sid
		}
	}
}

<timestamp_bits:42bit><datacenter_id_bit:3bit><process_id_bit:6bit><sequence_id_bits:12bit>

# 数据中心ID只有 3 bit表示，范围需要限制在 [0, 1, 2, 3, 4, 5, 6, 7]
SNOWFLAKE_CONFIG:
  datacenter_id: 1
  datacenter: "cn" 

	dataCenter := "sg"
	dataCenterID := int64(1)
	QuestionSnowflake = snowflakeetcd.GetGenerator(quesNameSpace, dataCenter, dataCenterID)

/<自定义>/_snowflake_/nodes/<datacenter>/<namespace>.<env>/<process_id>

// 具体实现
/xxx/_snowflake_/nodes/cn/xxx.dev/1

func make_snowflake(timestamp_ms int64, datacenter_id, process_id int64, sequence_id int64) int64 {
	// 将时间戳左移到指定高位，移动（datacenter_id_bits + datacenter_id_bits + sequence_id_bits) 位
	snowflakeid := ((timestamp_ms - twepoch) % max_timestamp) << datacenter_id_bits << process_id_bits << sequence_id_bits
	// 将数据中心 ID 移动 process_id_bits + sequence_id_bits 位
	snowflakeid += (datacenter_id % max_datacenter_id) << process_id_bits << sequence_id_bits
	// 将 process_id 移动 sequence_id_bits 位
	snowflakeid += (process_id % max_process_id) << sequence_id_bits
	// 序列化在低位，不需要移位操作
	snowflakeid += sequence_id % max_sequence_id
	return snowflakeid
}

// POST： /api/snowflake/v1/gen/
// Request: 
{
    "namespace": 1
}
// Response:
{
    "message": "success",
    "code": 0,
    "data": {
        "snowflake_id": 107209837483659272,
        "datacenter_id": 1,
    }
}

type SnowFlake struct {
	sequence      int64
	last_ts       int64
	last_seq      int64
	datacenter_id int64
	process_id    int64
	lock          sync.RWMutex
}

func (sf *SnowFlake) getSequnce() int64 {
	sf.sequence += 1
	sf.sequence %= max_sequence_id
	return sf.sequence
}

func (sf *SnowFlake) gen() int64 {
	sf.lock.Lock()
	defer sf.lock.Unlock()
	for {
		ts := make_timestamp()
		seq := sf.getSequnce()
		if ts == sf.last_ts && seq <= sf.last_seq {
			time.Sleep(1 * time.Millisecond)
		} else {
			sid := make_snowflake(ts, sf.process_id, sf.datacenter_id, seq)
			sf.last_ts = ts
			sf.last_seq = seq
			return sid
		}
	}
}

type SnowFlakeCloud struct {
	zk_namespace string //show be unique for each id field
	lock_path    string
	node_path    string
	zk_lock      ZkLockInterface
	zk_util      ZkUtilInterface
	sf           *SnowFlake
	datacenterID int64
}

func (sfc *SnowFlakeCloud) ensure_paths(paths string) error {
	return sfc.zk_util.EnsurePaths(paths)
}

func (sfc *SnowFlakeCloud) Init() {
	log.Println("sf Init begin", use_etcd)
	if use_etcd {
		sfc.zk_util = _etcd_util
		_ = sfc.ensure_paths(sfc.lock_path)
		sfc.zk_lock = NewEtcdLock(sfc.lock_path)
		//_ = sfc.ensure_paths(sfc.node_path)
	} else {
		sfc.zk_util = _zk_util
		_ = sfc.ensure_paths(sfc.lock_path)
		sfc.zk_lock = NewZkLock(sfc.lock_path)
		_ = sfc.ensure_paths(sfc.node_path)
	}
	log.Println("sf Init success", sfc.lock_path, sfc.node_path)
}

func (sfc *SnowFlakeCloud) register() {
	err := sfc.zk_lock.Lock()
	if err != nil {
		log.Panicln("sf lock err", err)
	}
	nodes, err := sfc.zk_util.Children(sfc.node_path)
	if err != nil {
		log.Panicln("sf get children err", err)
	}
	log.Println("sf exist nodes", nodes)
	var pid int64
	pid = 1
	if len(nodes) > 0 {
		node_ids := make(int64arr, 0, len(nodes))
		for _, s := range nodes {
			i, _ := strconv.ParseInt(s, 10, 64)
			node_ids = append(node_ids, i)
		}
		sort.Sort(node_ids)
		log.Println("sf node_ids", node_ids)
		if node_ids[len(node_ids)-1] < max_process_id-1 {
			pid = node_ids[len(node_ids)-1] + 1
		} else {
			log.Println("node reach max", node_ids[len(node_ids)-1])
			for i := int64(0); i < node_ids[len(node_ids)-1]+1; i++ {
				log.Println("node id", i)
				if i+1 != node_ids[i] {
					pid = i + 1
					break
				} else if i == int64(len(node_ids))-1 {
					pid = i + 2
					break
				} else if node_ids[i] != node_ids[i+1]-1 {
					pid = node_ids[i] + 1
					break
				}
			}
		}
	}
	log.Println("zksnowflake process_id", pid)
	pid_str := strconv.FormatInt(pid, 10)
	_, err = sfc.zk_util.CreateFlagEphemeral(sfc.node_path+"/"+pid_str, []byte(pid_str))
	if err != nil {
		log.Panicln("sf Create Ephemeral key err", sfc.node_path, err)
	}
	log.Println("sf Create Ephemeral key success", sfc.node_path, pid)
	sfc.sf = &SnowFlake{process_id: pid, datacenter_id: sfc.datacenterID}
	//
	err = sfc.zk_lock.Unlock()
	if err != nil {
		log.Panicln("sf unlock err", err)
	}
	log.Println("sf Create Ephemeral key ok", sfc.node_path, pid)
}

func (sfc *SnowFlakeCloud) Gen() int64 {
	return sfc.sf.gen()
}