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时用的或运算，反推用与运算。
本菜鸟切实体会到了位运算的精妙
