引用不知道谁说得名言:世界上没有两片完全相同的雪花,但是会有相同的ID
分布式系统中会将一个业务的系统部署到多台服务器上,用户随机访问其中一台,而之所以引入分布式系统就是为了让整个系统能够承载更大的访问量。诸如订单号这些我们需要它是全局唯一的,同时我们基本上都会将它作为查询条件;出于系统安全考虑不应当让其它人轻易的就猜出我们的订单号,同时也要防止公司的竞争对手直接通过订单号猜测出公司业务体量;为了保证系统的快速响应那么生成算法不能太耗时。而雪花算法正好解决了这些问题。
SnowFlake 算法(雪花算法), 是Twitter开源的分布式id生成算法。其核心思想就是: 使用一个64 bit的long型的数字作为全局唯一id。它的结构如下:
下面我们来对每一部分进一步的分析:
- 符号标识位(1位):计算机中为了区分负数(1)和正数(0),设计者将第一位做为符号位,ID通常使用正数,因此最高位固定为0;
- 41位时间截(毫秒),这个是使用 当前时间 减去 开始时间 得到的值;因此一旦我们的算法投入使用,那么程序中设置的开始时间就不能再去随意更改了,否则将可能出现重复的id值;
由于是基于时间来实现的且只有41位,由此可以计算出该算法只能使用70年左右:(2^41)/(1000*60*60*24*365) = 69.7 年
; - 10位机器ID:共计1024个节点,通常将其分为2部分:机房ID(dataCenterId) 和 机器ID(workerId);
- 12 位序列号:毫秒内的计数,共计4098个;简单来说就是每毫秒内从0开始计算得到值;
最终SnowFlake算法总结如下:整体上按照时间自增排序,并且整个分布式系统内不会产生ID 碰撞(由机房ID和机器ID作区分),并且效率较高。最多支持1024台机器,每台机器每毫秒能够生成最多4096个ID,整个集群理论上每秒可以生成 1024 * 1000 * 4096 = 42 亿个ID。
package main
import (
"errors"
"fmt"
"sync"
"time"
)
type SnowFlakeIdWorker struct {
// 开始时间戳
twepoch int64
// 机器ID所占的位数
workerIdBits int64
// 数据标识ID所占的位数
dataCenterIdBits int64
// 支持的最大机器ID
maxWorkerId int64
// 支持的最大机房 ID
maxDataCenterId int64
// 序列在ID中占的位数
sequenceBits int64
// 机器ID向左移位数
workerIdShift int64
// 机房ID向左移位数
dataCenterIdShift int64
// 时间截向左移位数
timestampLeftShift int64
// 生成序列的掩码最大值
sequenceMask int64
// 工作机器ID
workerId int64
// 机房ID
dataCenterId int64
/**
* 毫秒内序列
*/
sequence int64
// 上次生成ID的时间戳
lastTimestamp int64
// 锁
lock sync.Mutex
}
func (p *SnowFlakeIdWorker) init(dataCenterId int64, workerId int64) {
// 开始时间戳;这里是2021-06-01
p.twepoch = 1622476800000
// 机器ID所占的位数
p.workerIdBits = 5
// 数据标识ID所占的位数
p.dataCenterIdBits = 5
// 支持的最大机器ID,最大是31
p.maxWorkerId = -1^(-1 << p.workerIdBits)
// 支持的最大机房ID,最大是 31
p.maxDataCenterId = -1^(-1 << p.dataCenterIdBits)
// 序列在ID中占的位数
p.sequenceBits = 12
// 机器ID向左移12位
p.workerIdShift = p.sequenceBits
// 机房ID向左移17位
p.dataCenterIdShift = p.sequenceBits+p.workerIdBits
// 时间截向左移22位
p.timestampLeftShift = p.sequenceBits+p.workerIdBits+p.dataCenterIdBits
// 生成序列的掩码最大值,最大为4095
p.sequenceMask = -1^(-1 << p.sequenceBits)
if workerId > p.maxWorkerId || workerId < 0 {
panic(errors.New(fmt.Sprintf("Worker ID can't be greater than %d or less than 0", p.maxWorkerId)))
}
if dataCenterId > p.maxDataCenterId || dataCenterId < 0 {
panic(errors.New(fmt.Sprintf("DataCenter ID can't be greater than %d or less than 0", p.maxDataCenterId)))
}
p.workerId = workerId
p.dataCenterId = dataCenterId
// 毫秒内序列(0~4095)
p.sequence = 0
// 上次生成 ID 的时间戳
p.lastTimestamp = -1
}
// 生成ID,注意此方法已经通过加锁来保证线程安全
func (p *SnowFlakeIdWorker) nextId() int64 {
p.lock.Lock()
defer p.lock.Unlock()
timestamp := p.timeGen()
// 如果当前时间小于上一次 ID 生成的时间戳,说明发生时钟回拨,为保证ID不重复抛出异常。
if timestamp < p.lastTimestamp {
panic(errors.New(fmt.Sprintf("Clock moved backwards. Refusing to generate id for %d milliseconds", p.lastTimestamp - timestamp)))
}
if p.lastTimestamp == timestamp {
// 同一时间生成的,则序号+1
p.sequence = (p.sequence + 1) & p.sequenceMask
// 毫秒内序列溢出:超过最大值
if p.sequence == 0 {
// 阻塞到下一个毫秒,获得新的时间戳
timestamp = p.tilNextMillis(p.lastTimestamp)
}
} else {
// 时间戳改变,序列重置
p.sequence = 0
}
// 保存本次的时间戳
p.lastTimestamp = timestamp
// 移位并通过或运算拼到一起
return ((timestamp - p.twepoch) << p.timestampLeftShift) |
(p.dataCenterId << p.dataCenterIdShift) |
(p.workerId << p.workerIdShift) | p.sequence
}
func (p *SnowFlakeIdWorker) tilNextMillis(lastTimestamp int64) int64 {
timestamp := p.timeGen()
for ;timestamp <= lastTimestamp; {
timestamp = p.timeGen()
}
return timestamp
}
func (p *SnowFlakeIdWorker) timeGen() int64 {
return time.Now().UnixNano()/1e6
}
func main() {
idWorker := &SnowFlakeIdWorker{}
idWorker.init(0, 2)//机房和机器ID不能超过31
fmt.Println(idWorker.nextId())
}
php实现
<?php
class Snowflake
{
const TWEPOCH = 1587571200000;//2020-04-23 00:00:00
const WORKER_ID_BITS = 5; // 机器标识位数
const DATACENTER_ID_BITS = 5; // 数据中心标识位数
const SEQUENCE_BITS = 12; // 毫秒内自增位
const max12bit = -1 ^ (-1 << self::SEQUENCE_BITS);
const max41bit = 1587484800000;//2020-04-22 00:00:00
static $machineId = null;
static $centerDataId = null;
public static function setMachineIdAndCenID($mId = 0,$cId = 0) {
self::$machineId = $mId;
self::$centerDataId = $cId;
}
public static function generateParticle() {
//现在的毫秒时间戳 - 42 bits
$time = floor(microtime(true) * 1000);
//现在的时间减去指定的时间
$time -= self::TWEPOCH;
//创建一个基础时间
$base = decbin(self::max41bit + $time);
//配置机器id,与 数据中心id 一共10 bit 最多可以有1024台机器(为配置情况下,自动填充)
if(!self::$machineId) {
$machineid = str_pad(decbin(self::$machineId), self::WORKER_ID_BITS, "0", STR_PAD_LEFT);
} else {
$machineid = self::$machineId;
}
if(self::$centerDataId) {
$centerDataId = self::$centerDataId;
} else {
$centerDataId = str_pad(decbin(self::$centerDataId), self::DATACENTER_ID_BITS, "0", STR_PAD_LEFT);
}
// 序列号 12bits 最多可以有4096个随机数 #TODO 这块应该实现一个毫秒内递增
$random = str_pad(decbin(mt_rand(0, self::max12bit)), self::SEQUENCE_BITS, "0", STR_PAD_LEFT);
//连接
$suffix = 0;
$base = $suffix.$base.$centerDataId.$machineid.$random;
//返回唯一id
return bindec($base);
}
public static function timeFromParticle($particle) {
/*
* Return time
*/
return bindec(substr(decbin($particle),0,41)) - self::max41bit + self::TWEPOCH;
}
}