golang 结合etcd利用雪花算法实现全局递增唯一ID

1.雪花算法

图片来自 https://zhuanlan.zhihu.com/p/...

• 生成的序列号是由64位表示
• 最高位为0，表示是正数
• 第2到第42位表示时间间隔，其计算是使用当前时间减去一个起始时间得到一个时间间隔，41位大约可以保存69年的时间范围，也就是说起始时间是2021年的话，大约在2090年用完，足够使用了
• 第43位到第52位为具体服务的id，服务的id是使用etcd来实现全局唯一的也可以使用redis进行实现，最多1024个，也就是说所有服务最多1024个，包括起来多个的服务
• 第53位到第64位为同一时间下递增的序列号

2.源码如下，研究可以看注释

实现只放在一个源文件里面了，具体的可以进行放在不同的包中进行调用，雪花算法的实现可以单独放在一个worker包中供所有服务调用

package main

import (
    "context"
    "errors"
    "go.etcd.io/etcd/clientv3"
    "log"
    "strconv"
    "sync"
    "time"
)

const(
    WORKERIDBits = 10 //wokerId 占10位bit
    SEQUENCEBITS = 12 //序列号占的bit位数
    MAXSEQUENCE = int64(-1) ^ (int64(-1) << SEQUENCEBITS) //序列号的最大值
    MAXWORKERID = int64(-1) ^ (int64(-1) << WORKERIDBits) //workerId的最大值

    TIMESTAMP_OFFSET = uint(22) //时间戳的偏移位数
    WORKERID_OFFSET = uint(12) //workerId的偏移位数
    TIME_START_STAMP = int64(1589923200000) // 起始时间 2020-05-20 08:00:00 +0800 CST
)

//-----------------------------workerId---------------------------
var CurrentWorkNodeNum string     //当前节点number 节点number从1开始 最大值为1024
var WokerNodePrefix = "worker" //节点key前缀 节点值为CurrentWorkNodeNum   例如 worker1 = 1 worker2 = 2
var wg sync.WaitGroup

func WorkerId() error {
    if len(CurrentWorkNodeNum) != 0 {                        //CurrentWorkNodeNum 如果已经初始化过了，直接返回
        return errors.New("CurrentWorkNodeNum inited")
    }
    client, err := clientv3.New(clientv3.Config{
        Endpoints:   []string{"http://192.168.56.111:2379"},      //etcd端 可以抽离出来
        DialTimeout: 2 * time.Second,
    })
    if err != nil {
        log.Println("create client err:",err)
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    resp,err := client.Get(ctx, WokerNodePrefix,clientv3.WithPrefix())      //获取所有前缀为worker的节点
    cancel()
    if err != nil {
        return errors.New("get prefix worker node error")
    }
    existNodeMap := make(map[int]int)       //定义一个map，保存已经存在的节点
    for _,ev := range resp.Kvs {
        num, _ := strconv.Atoi(string(ev.Value))
        existNodeMap[num] = num             //put到existNodeMap中
        log.Printf("%s:%s \n",ev.Key,ev.Value)
    }
    count := 1                                //从1到1024找最小的number
    for  ;count < 1025; count++ {
        if _, ok := existNodeMap[count];!ok {   //如果不存在，就会直接break
            CurrentWorkNodeNum = strconv.Itoa(count)
            break
        }
    }
    if count == 1024 {                 //代表1024个节点都已经用完了，或者部分节点已经挂掉了，然后key的租期还没有结束，可以重新启动
        return errors.New("服务节点数目大于1024")
    }
    go ActiveCurrentWorkerNode(client) //启动一个协程一直激活当前key,如果当前服务挂了，key就会在租期结束后查询不到了
    return nil
}

func ActiveCurrentWorkerNode(client *clientv3.Client){
    for {
        leasetime := int64(60)    //租期时间
        sleeptime := 50    //当前协程睡眠时间，小于租期时间即可
        lease := clientv3.NewLease(client)
        log.Println("active currerntNode :",CurrentWorkNodeNum)
        if leaseRes,err := lease.Grant(context.TODO(),leasetime);err != nil {
            panic(err)
        }else {
            _, err := client.Put(context.Background(), WokerNodePrefix+CurrentWorkNodeNum, CurrentWorkNodeNum,clientv3.WithLease(leaseRes.ID))
            if err != nil {
                panic(err)
            }
        }
        time.Sleep(time.Second * time.Duration(sleeptime))
    }
}
//-----------------------------workerId---------------------------

type SnowFlakeWorker struct{
    mu sync.Mutex   //互斥锁
    LastTimestamp int64 //上一次的时间间隔
    WorkerID int64   //该服务的wokerID
    Sequence int64 //同一时间戳下的序列号
}

func New(wokerID int64) *SnowFlakeWorker{
    return &SnowFlakeWorker{
        WorkerID: wokerID,
        LastTimestamp: 0,
        Sequence: 0,
    }
}

func (s *SnowFlakeWorker) getMilliSeconds() int64{
    return time.Now().UnixNano() / 1e6      //当前时间的毫秒数
}

func (s *SnowFlakeWorker) NextID() (uint64,error){
    s.mu.Lock()     //加锁
    defer s.mu.Unlock()
    timeStamp := s.getMilliSeconds()   //当前时间毫秒数
    if timeStamp < s.LastTimestamp {   //当前时间毫秒数小于上一次的毫秒数，错误直接抛出异常
         return 0,errors.New("currentTime is before timestamp")
    }
    if timeStamp == s.LastTimestamp {     //如果相等则sequenc加1
         s.Sequence = (s.Sequence + 1) & MAXSEQUENCE
        if s.Sequence == 0 {     //加1取余MAXSEQUENCE 说明当前毫秒数的序列号使用完毕，需要等待下一个毫秒数
            for timeStamp <= s.LastTimestamp {   //等待到下一个毫秒数就退出
                 timeStamp = s.getMilliSeconds()
            }
        }
    }else {
        s.Sequence = 0 //如果大于LastTimestamp 则sequence为0
    }
    s.LastTimestamp = timeStamp
    return uint64((timeStamp - TIME_START_STAMP) << TIMESTAMP_OFFSET | s.WorkerID << WORKERIDBits |s.Sequence),nil
}

func main() {
    wg.Add(1)
    err := WorkerId()
    if err != nil {
        log.Println("worker inited error:",err)
        return
    }
    currentWorkerNodeNum, _ := strconv.Atoi(CurrentWorkNodeNum)
    worker := New(int64(currentWorkerNodeNum))
    for i := 1;i<10;i++ {
        id, err := worker.NextID()
        if err != nil {
            log.Println("generate snowflake id,error:",err)
            return
        }
        log.Println("snowflakeId:",id)
    }
    wg.Wait()
}

3.测试结果

2021-08-03 17:38:16.416241 I | worker1:1
2021-08-03 17:38:16.416241 I | worker2:2
2021-08-03 17:38:16.416241 I | snowflakeId: 159636453498817536
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453498817537
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453503011840
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453503011841
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453503011842
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453503011843
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453503011844
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453503011845
2021-08-03 17:38:16.417196 I | snowflakeId: 159636453503011846
2021-08-03 17:38:16.417196 I | active currerntNode : 3