github地址：https://github.com/bwmarrin/snowflake

總共就300行代碼，主要邏輯也就100行吧。

這是一款大數據量下的id生成器的snowflake-golang實現，snowflake生成的id (int64類型)包含毫秒時間戳、機器id、同一毫秒下的自增id這3部分數據，這里面主要是位運算的妙用(好多開源項目都會用到位運算)

用int64的64bit存儲以下部分：

• 12bit的自增id step(同一毫秒下)
• 10bit的機器id node(多臺機器)
• 41bit的毫秒時間間距 time(不用從1970開始算)
• 1bit的unset 預留

這幾個參數,12bit 10bit 41bit 1bit其實都可以根據自己情況自定義：

• 41bit的毫秒time最多可以表示((1<<41)-1) / (86400*1000*465) = 69.7年(減1是因為包括0)
• 10bit的node最多可表示(1<<10)-1=1023個機器
• 12bit的step同一毫秒最多可表示(1<<12)-1=4095個自增id (同一機器同一毫秒生產的id數目大于4095怎么辦，代碼就體現了)

看看怎么用：

    // Create a new Node with a Node number of 1
    node, err := snowflake.NewNode(1)
    if err != nil {
        fmt.Println(err)
        return
    }

    // Generate a snowflake ID.
    id := node.Generate()

    // Print out the ID's timestamp
    fmt.Printf("ID Time  : %d\n", id.Time())

    // Print out the ID's node number
    fmt.Printf("ID Node  : %d\n", id.Node())

    // Print out the ID's sequence number
    fmt.Printf("ID Step  : %d\n", id.Step())

先來生成id

不過生成id前,先new一個node對象

func NewNode(node int64) (*Node, error) {

    n := Node{}
    n.node = node
    n.nodeMax = -1 ^ (-1 << NodeBits) // == (1<< NodeBits) - 1
    n.nodeMask = n.nodeMax << StepBits // nodeMask以及stepMask主要用來由生成的id反推node和step
    n.stepMask = -1 ^ (-1 << StepBits) // == (1<< StepBits) - 1
    n.timeShift = NodeBits + StepBits // time右移NodeBits + StepBits才是id中time對應的位置
    n.nodeShift = StepBits // node右移StepBits才是id中node對應的位置
    // step是從0位到12位

    if n.node < 0 || n.node > n.nodeMax {
        return nil, errors.New("Node number must be between 0 and " + strconv.FormatInt(n.nodeMax, 10))
    }

    var curTime = time.Now()
    // add time.Duration to curTime to make sure we use the monotonic clock if available
    n.epoch = curTime.Add(time.Unix(Epoch/1000, (Epoch%1000)*1000000).Sub(curTime))

    return &n, nil
}

以上的StepBits, NodeBits, Epoch都是配置項

• StepBits = 12
• NodeBits = 10
• Epoch = 1288834974657 (毫秒時間戳，這里表示的是2010年)

注意Epoch不用從1970開始算，總共才有41bit表示毫秒時間，從1970開始有點浪費，可以設置為距項目上線時間最近的時間，可以持續69年生成id。如果從1970年開始算，41bit還可以存儲18年的毫秒時間

正式生成id

func (n *Node) Generate() ID {

    n.mu.Lock()

    // nanoseconds 1e9
    // now單位毫秒
    now := time.Since(n.epoch).Nanoseconds() / 1000000

    // 每毫秒可以產生n.stepMask個id
    // n.step的值[0, n.stepMask]
    if now == n.time {
        n.step = (n.step + 1) & n.stepMask

        // 當1毫秒產生的id個數大于n.stepMask時
        if n.step == 0 {
            // 強制sleep直到下一毫秒
            for now <= n.time {
                now = time.Since(n.epoch).Nanoseconds() / 1000000
            }
        }
    } else {
        // 當前這一毫秒還沒有生成id,用0即可
        n.step = 0
    }

    n.time = now

    // 所以r由3部分組成: time node step
    // shift表示位移量
    // 或操作 只要對應位有1個為1就為1，方便由r反推time node step
    r := ID((now)<<n.timeShift |
        (n.node << n.nodeShift) |
        (n.step),
    )

    n.mu.Unlock()
    return r
}

所以上面的問題，同一臺機器1ms生成的id數大于4095就是死循環直到下一個ms.

由id反推time node step

func (f ID) Time() int64 {
    return (int64(f) >> timeShift) + Epoch
}

func (f ID) Node() int64 {
    // 位運算優先級高
    return int64(f) & nodeMask >> nodeShift
}

func (f ID) Step() int64 {
    // f的后stepBits位為step
    // stepMask為step所占用的stepBits個位的最大值
    // 與運算結果的最大值為stepMask
    return int64(f) & stepMask
}

生成id時用的或運算，反推用與運算。
本菜鳥切實體會到了位運算的精妙