golang 实现雪花算法

雪花算法概述

snowflake 是 twitter 开源的分布式ID生成算法,其核心思想为,一个long型的ID:

  • 41 bit 作为毫秒数 - 41位的长度可以使用69年
  • 10 bit 作为机器编号 (5个bit是数据中心,5个bit的机器ID) - 10位的长度最多支持部署1024个节点
  • 12 bit 作为毫秒内序列号 - 12位的计数顺序号支持每个节点每毫秒产生4096个ID序号

雪花算法原理

代码实现

package main

import (
	"fmt"
	"sync"
	"time"
)

// 服务上线时间毫秒时间戳
const startTime = 1698734492000

// SnowflakeId组成:timestamps[41bits]  workId[10bits] seqId[12bits]
type snowflakeIdWorker struct {
	sync.Mutex
	workId   int //[0,1024)
	lastTms  int64
	seqInTms int //[0,4096)
}

func NewSnowflakeIdWorker(workId int) *snowflakeIdWorker {
	return &snowflakeIdWorker{
		Mutex:    sync.Mutex{},
		workId:   workId,
		lastTms:  0,
		seqInTms: 0,
	}
}

func (p *snowflakeIdWorker) GetUUID() int64 {
	p.Lock()
	defer p.Unlock()

	nowTms := time.Now().UnixNano() / 1e6
	if nowTms == p.lastTms {
		p.seqInTms = (p.seqInTms + 1) & (1<<12 - 1)
		if p.seqInTms == 0 {
			for nowTms == p.lastTms {
				nowTms = time.Now().UnixNano() / 1e6
			}
		}
	} else {
		p.seqInTms = 0
		p.lastTms = nowTms
	}
	return (nowTms - startTime)<<22 | int64(p.workId)<<12 | int64(p.seqInTms)
}

func main() {
	worker := NewSnowflakeIdWorker(1)
	for i := 0; i < 10000; i++ {
		a := worker.GetUUID()
		b := fmt.Sprintf("%b", a)
		fmt.Println("a", a, "b", b, "len(b):", len(b))
	}
}
雪花算法是一种分布式唯一ID生成算法,它可以保证在分布式环境下生成唯一的ID。在Golang中,我们可以使用以下代码实现雪花算法: ```go package main import ( "errors" "fmt" "sync" "time" ) const ( // StartTime 是雪花算法开始时间戳,用于减小生成的ID长度 StartTime = 1577808000000 // 2020-01-01 00:00:00的时间戳,单位毫秒 // MachineIDBits 机器ID的位数 MachineIDBits = 10 // SequenceBits 序列号的位数 SequenceBits = 12 // MachineIDShift 机器ID的移位长度 MachineIDShift = SequenceBits // TimestampShift 时间戳的移位长度 TimestampShift = SequenceBits + MachineIDBits // MaxMachineID 最大机器ID MaxMachineID = -1 ^ (-1 << MachineIDBits) // MaxSequence 最大序列号 MaxSequence = -1 ^ (-1 << SequenceBits) ) // Snowflake 是雪花算法生成的唯一ID结构体 type Snowflake struct { machineID int64 // 机器ID sequence int64 // 序列号 lastStamp int64 // 上次生成ID的时间戳 idLock sync.Mutex } // NewSnowflake 创建一个新的雪花算法实例 func NewSnowflake(machineID int64) (*Snowflake, error) { if machineID < 0 || machineID > MaxMachineID { return nil, errors.New("machine ID out of range") } return &Snowflake{ machineID: machineID, }, nil } // Generate 生成一个新的唯一ID func (s *Snowflake) Generate() int64 { s.idLock.Lock() defer s.idLock.Unlock() // 获取当前时间戳 now := time.Now().UnixNano() / 1e6 // 如果当前时间小于上次生成ID的时间戳,说明系统时间被调整过,此时应该返回错误 if now < s.lastStamp { panic(fmt.Sprintf("time is moving backwards, refusing to generate id for %d milliseconds", s.lastStamp-now)) } // 如果当前时间与上次生成ID的时间戳相同,说明在同一毫秒内生成了多次ID,此时应将序列号+1 if now == s.lastStamp { s.sequence = (s.sequence + 1) & MaxSequence if s.sequence == 0 { // 序列号已经达到最大值,等待下一毫秒 for now <= s.lastStamp { now = time.Now().UnixNano() / 1e6 } } } else { // 当前时间与上次生成ID的时间戳不同,说明已经进入下一毫秒,序列号重置为0 s.sequence = 0 } // 保存当前时间戳,用于下一次生成ID时使用 s.lastStamp = now // 生成ID id := (now-StartTime)<<TimestampShift | (s.machineID << MachineIDShift) | s.sequence return id } func main() { // 创建一个新的雪花算法实例,机器ID为1 sf, err := NewSnowflake(1) if err != nil { panic(err) } // 生成10个唯一ID for i := 0; i < 10; i++ { id := sf.Generate() fmt.Println(id) } } ``` 在上面的代码中,我们首先定义了一些常量,包括开始时间、机器ID的位数、序列号的位数等。然后,我们定义了一个Snowflake结构体,用于保存生成ID时需要用到的一些参数,如机器ID、序列号、上次生成ID的时间戳等。接着,我们定义了NewSnowflake函数,用于创建一个新的雪花算法实例,并检查机器ID是否超出范围。最后,我们定义了Generate函数,用于生成一个新的唯一ID。在Generate函数中,我们首先获取当前时间戳,然后判断当前时间是否小于上次生成ID的时间戳,如果是,则说明系统时间被调整过,此时应该返回错误;如果当前时间与上次生成ID的时间戳相同,则说明在同一毫秒内生成了多次ID,此时应将序列号+1;如果当前时间与上次生成ID的时间戳不同,则说明已经进入下一毫秒,序列号重置为0。最后,我们将当前时间戳、机器ID、序列号组合成一个64位的唯一ID返回。 在main函数中,我们创建了一个新的雪花算法实例,并调用Generate函数生成了10个唯一ID。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值