SnowFlake算法是一种以划分命名空间来生成ID的一种算法,生成id的结果是一个64bit大小的整数。
优点:
- 毫秒数在高位,自增序列在低位,整个ID都是趋势递增的。
- 不依赖数据库等第三方系统,以服务的方式部署,稳定性更高,生成ID的性能也是非常高的。
- 可以根据自身业务特性分配bit位,非常灵活。
缺点:
- 强依赖机器时钟,如果机器上时钟回拨,会导致发号重复或者服务会处于不可用状态。
实现代码(不同命名空间所占用的位数可根据业务需要自行调整):
import (
"errors"
"fmt"
"sync"
"time"
)
const (
twepoch = int64(1417937700000) // 默认起始的时间戳 1449473700000 。计算时,减去这个值
DistrictIdBits = uint(5) //区域 所占用位置
NodeIdBits = uint(9) //节点 所占位置
sequenceBits = uint(10) //自增ID 所占用位置
/*
* SnowFlake
* 1 符号位 | 39 时间戳 | 5 区域 | 9 节点 | 10 (毫秒内)自增ID
* 0 | 0000000 00000000 00000000 00000000 00000000 | 00000 | 000000 000 | 000000 0000
*
*/
maxNodeId = -1 ^ (-1 << NodeIdBits) //节点 ID 最大范围
maxDistrictId = -1 ^ (-1 << DistrictIdBits) //最大区域范围
nodeIdShift = sequenceBits //左移次数
DistrictIdShift = sequenceBits + NodeIdBits
timestampLeftShift = sequenceBits + NodeIdBits + DistrictIdBits
sequenceMask = -1 ^ (-1 << sequenceBits)
maxNextIdsNum = 100 //单次获取ID的最大数量
)
type IdWorker struct {
sequence int64 //序号
lastTimestamp int64 //最后时间戳
nodeId int64 //节点ID
twepoch int64
districtId int64
mutex sync.Mutex
}
// NewIdWorker new a snowflake id gg object.
func NewIdWorker(NodeId int64) (*IdWorker, error) {
var districtId int64
districtId = 1 //暂时默认给1 ,方便以后扩展
idWorker := &IdWorker{}
if NodeId > maxNodeId || NodeId < 0 {
fmt.Sprintf("NodeId Id can't be greater than %d or less than 0", maxNodeId)
return nil, errors.New(fmt.Sprintf("NodeId Id: %d error", NodeId))
}
if districtId > maxDistrictId || districtId < 0 {
fmt.Sprintf("District Id can't be greater than %d or less than 0", maxDistrictId)
return nil, errors.New(fmt.Sprintf("District Id: %d error", districtId))
}
idWorker.nodeId = NodeId
idWorker.districtId = districtId
idWorker.lastTimestamp = -1
idWorker.sequence = 0
idWorker.twepoch = twepoch
idWorker.mutex = sync.Mutex{}
fmt.Sprintf("worker starting. timestamp left shift %d, District id bits %d, worker id bits %d, sequence bits %d, workerid %d", timestampLeftShift, DistrictIdBits, NodeIdBits, sequenceBits, NodeId)
return idWorker, nil
}
// timeGen generate a unix millisecond.
func timeGen() int64 {
return time.Now().UnixNano() / int64(time.Millisecond)
}
// tilNextMillis spin wait till next millisecond.
func tilNextMillis(lastTimestamp int64) int64 {
timestamp := timeGen()
for timestamp <= lastTimestamp {
timestamp = timeGen()
}
return timestamp
}
// NextId get a snowflake id.
func (id *IdWorker) NextId() (int64, error) {
id.mutex.Lock()
defer id.mutex.Unlock()
return id.nextid()
}
// NextIds get snowflake ids.
func (id *IdWorker) NextIds(num int) ([]int64, error) {
if num > maxNextIdsNum || num < 0 {
fmt.Sprintf("NextIds num can't be greater than %d or less than 0", maxNextIdsNum)
return nil, errors.New(fmt.Sprintf("NextIds num: %d error", num))
}
ids := make([]int64, num)
id.mutex.Lock()
defer id.mutex.Unlock()
for i := 0; i < num; i++ {
ids[i], _ = id.nextid()
}
return ids, nil
}
func (id *IdWorker) nextid() (int64, error) {
timestamp := timeGen()
if timestamp < id.lastTimestamp {
fmt.Sprintf("clock is moving backwards. Rejecting requests until %d.", id.lastTimestamp)
return 0, errors.New(fmt.Sprintf("Clock moved backwards. Refusing to generate id for %d milliseconds", id.lastTimestamp-timestamp))
}
if id.lastTimestamp == timestamp {
id.sequence = (id.sequence + 1) & sequenceMask
if id.sequence == 0 {
timestamp = tilNextMillis(id.lastTimestamp)
}
} else {
id.sequence = 0
}
id.lastTimestamp = timestamp
return ((timestamp - id.twepoch) << timestampLeftShift) | (id.districtId << DistrictIdShift) | (id.nodeId << nodeIdShift) | id.sequence, nil
}
Golang可用以下代码获取机器ip,然后传给上面的NewIdWorker()
方法。
func getNodeId() int64 {
addrs, err := net.InterfaceAddrs()
if err != nil {
fmt.Printf("Get IP failed:[%v]", err)
}
for _, address := range addrs {
// 检查ip地址判断是否回环地址
if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
if ipnet.IP.To4() != nil {
nodeId := ipToInt64(ipnet.IP) % maxNodeId
fmt.Printf("Ip address:[%v], nodeId:[%v]", ipnet.IP, nodeId)
return nodeId
}
}
}
return rand.Int63() % maxNodeId
}
func ipToInt64(ip net.IP) int64 {
bits := strings.Split(ip.String(), ".")
b0, _ := strconv.Atoi(bits[0])
b1, _ := strconv.Atoi(bits[1])
b2, _ := strconv.Atoi(bits[2])
b3, _ := strconv.Atoi(bits[3])
var sum int64
sum += int64(b0) << 24
sum += int64(b1) << 16
sum += int64(b2) << 8
sum += int64(b3)
return sum
}