雪花算法(snowflake)：用於生成分布式ID（純數字，時間順序）,訂單編號等

自增ID：記錄可以根據ID號進行推測出來，對於數據敏感場景不宜使用。
GUID：采用無意義字符串，數據量增大時造成訪問過慢，且不宜排序。

雪花算法描述：

• 最高位是符號位，始終為0，不可用。
• 41位的時間序列，精確到毫秒級，41位的長度可以使用69年。時間位還有一個很重要的作用是可以根據時間進行排序。
• 10位的機器標識，10位的長度最多支持部署1024個節點。
• 12位的計數序列號，序列號即一系列的自增id，可以支持同一節點同一毫秒生成多個ID序號，12位的計數序列號支持每個節點每毫秒產生4096個ID序號。

Golang版

snowflake.go

package snowflake
// twitter 雪花算法
// 把時間戳,工作機器ID, 序列號組合成一個 64位 int
// 第一位置零, [2,42]這41位存放時間戳,[43,52]這10位存放機器id,[53,64]最後12位存放序列號

import "time"
var (
    machineID    int64 // 機器 id 占10位, 十進制範圍是 [ 0, 1023 ]
    sn            int64 // 序列號占 12 位,十進制範圍是 [ 0, 4095 ]
    lastTimeStamp int64
 
 // 上次的時間戳(毫秒級), 1秒=1000毫秒, 1毫秒=1000微秒,1微秒=1000納秒
)

func init() {
    lastTimeStamp = time.Now().UnixNano() / 1000000
}

func SetMachineId(mid int64) {
    // 把機器 id 左移 12 位,讓出 12 位空間給序列號使用
    machineID = mid << 12
}

func GetSnowflakeId() int64 {
    curTimeStamp := time.Now().UnixNano() / 1000000
    // 同一毫秒
    if curTimeStamp == lastTimeStamp {
        sn++
        // 序列號占 12 位,十進制範圍是 [ 0, 4095 ]
 

        if sn > 4095 {
            time.Sleep(time.Millisecond)
            curTimeStamp = time.Now().UnixNano() / 1000000
            lastTimeStamp = curTimeStamp
            sn = 0
        }

        // 取 64 位的二進制數 0000000000 0000000000 0000000000 0001111111111 1111111111 1111111111  1 ( 這裏共 41 個 1 )和時間戳進行並操作
        // 並結果( 右數 )第 42 位必然是 0,  低 41 位也就是時間戳的低 41 位
        rightBinValue := curTimeStamp & 0x1FFFFFFFFFF
        // 機器 id 占用10位空間,序列號占用12位空間,所以左移 22 位; 經過上面的並操作,左移後的第 1 位,必然是 0
        rightBinValue <<= 22
        id := rightBinValue | machineID | sn
        return id
    }
    if curTimeStamp > lastTimeStamp {
        sn = 0
        lastTimeStamp = curTimeStamp
        // 取 64 位的二進制數 0000000000 0000000000 0000000000 0001111111111 1111111111 1111111111  1 ( 這裏共 41 個 1 )和時間戳進行並操作
        // 並結果( 右數 )第 42 位必然是 0,  低 41 位也就是時間戳的低 41 位
        rightBinValue := curTimeStamp & 0x1FFFFFFFFFF
        // 機器 id 占用10位空間,序列號占用12位空間,所以左移 22 位; 經過上面的並操作,左移後的第 1 位,必然是 0
        rightBinValue <<= 22
        id := rightBinValue | machineID | sn
        return id
    }
    if curTimeStamp < lastTimeStamp {
        return 0
    }
    return 0
}

main.go

package main
import (
    "fmt"
    "reflect"
    "snowflake"
    "time"
)

func main() {
    //var ids = []int64{}
    var ids = make([]int64, 0)

    //設置一個機器標識，如IP編碼,防止分布式機器生成重復碼
    snowflake.SetMachineId(192168100101)

    fmt.Println("start", time.Now().Format("13:04:05"))
    for i := 0; i < 10000000; i++ {
        id := snowflake.GetSnowflakeId()
        ids = append(ids, id)
    }
    fmt.Println("end  ", time.Now().Format("13:04:05"))

    result := Duplicate(ids)
    fmt.Println("去重後數量：", len(result))
    fmt.Println(result[10], result[11], result[12], result[13], result[14])
    fmt.Println(result[9990], result[9991], result[9992], result[9993], result[9994])
}

//去重
func Duplicate(a interface{}) (ret []interface{}) {
    va := reflect.ValueOf(a)
    for i := 0; i < va.Len(); i++ {
        if i > 0 && reflect.DeepEqual(va.Index(i-1).Interface(), va.Index(i).Interface()) {
            continue
        }
        ret = append(ret, va.Index(i).Interface())
    }
    return ret
}

註意：在分布式系統中給每臺機器設置一個int64的機器碼，可以是IP編號+隨機數，如192168011234（192.168.0.1+1234）

測試結果：

結論：

理論上生成速率為kw/秒，所以完全滿足一般企業級應用， 算法可靠（去重處理在此也是多此一舉）；
性能：100W+/秒；

參考：
https://blog.csdn.net/u011499747/article/details/78254990

雪花算法