目录
分布式: 雪花算法(SnowFlake)
雪花算法可以帮助我们在分布式环境中保证全局唯一标识。
雪花算法 (SnowFlake )算法,是 Twitter 开源的分布式 id 生成算法。
有这么一种说法,自然界中并不存在两片完全一样的雪花的。每一片雪花都拥有自己漂亮独特的形状、独一无二。雪花算法也表示生成的ID如雪花般独一无二。
核心思想是:使用一个 64 bit 的 long 型的数字作为全局唯一 id。在分布式系统中的应用十分广泛,且ID 引入了时间戳,基本上保持自增的。
这 64 个 bit 中,其中 1 个 bit 是不用的(我们生成的 id 都是正数,所以第一个 bit 统一都是 0),然后用其中的 41 bit 作为毫秒数,用 10 bit 作为工作机器 id,12 bit 作为序列号。
这个算法可以保证说,一个机房的一台机器上,在同一毫秒内,生成了一个唯一的 id。可能一个毫秒内会生成多个 id,但是有最后 12 个 bit 的序号来区分开来。
给大家举个例子吧,比如下面那个 64 bit 的 long 型数字:
-
第一个部分,是 1 个 bit:0,这个是无意义的。
-
第二个部分是 41 个 bit:表示的是时间戳。
-
第三个部分是 5 个 bit:表示的是机房 id,10001。
-
第四个部分是 5 个 bit:表示的是机器 id,1 1001。
-
第五个部分是 12 个 bit:表示的序号,就是某个机房某台机器上这一毫秒内同时生成的 id 的序号,0000 00000000。①1 bit:是不用的,为啥呢?
①. 因为二进制里第一个 bit 为如果是 1,那么都是负数,但是我们生成的 id 都是正数,所以第一个 bit 统一都是 0。
②41 bit:表示的是时间戳,单位是毫秒。
41 bit 可以表示的数字多达 2^41 - 1,也就是可以标识 2 ^ 41 - 1 个毫秒值,换算成年就是表示 69 年的时间。
③10 bit:记录工作机器 id,代表的是这个服务最多可以部署在 2^10 台机器上,也就是 1024 台机器。
但是 10 bit 里 5 个 bit 代表机房 id,5 个 bit 代表机器 id。意思就是最多代表 2
5 个机房(32 个机房),每个机房里可以代表 2 ^ 5 个机器(32 台机器),也可以根据自己公司的实际情况确定。
④12 bit:这个是用来记录同一个毫秒内产生的不同 id。
12 bit 可以代表的最大正整数是 2 ^ 12 - 1 = 4096,也就是说可以用这个 12 bit 代表的数字来区分同一个毫秒内的 4096 个不同的 id。
为什么
SnowFlake可以保证:
所有生成的id按时间趋势递增,
整个分布式系统内不会产生重复id(因为有datacenterId和workerId来做区分)
SnowFlake算法的优点:
(1)高性能高可用:生成时不依赖于数据库,完全在内存中生成。
(2)容量大:每秒中能生成数百万的自增ID。
(3)ID自增:存入数据库中,索引效率高。
SnowFlake算法的缺点:
依赖系统时间的一致性,如果系统时间被回调,或者改变,可能会造成id冲突或者重复。
扩展:唯一ID生产方法
唯一ID可以标识数据的唯一性,在分布式系统中生成唯一ID的方案有很多,常见的方式大概有以下三种:
- 依赖数据库,使用如MySQL自增列或Oracle序列等。
- UUID随机数
- snowflake雪花算法
数据库和UUID方案的不足之处
采用数据库自增序列:
读写分离时,只有主节点可以进行写操作,可能有单点故障的风险
分表分库,数据迁移合并等比较麻烦
UUID随机数:
采用无意义字符串,没有排序
UUID使用字符串形式存储,数据量大时查询效率比较低
代码实现
package com.kx.utils.id.impl;
import com.kx.config.KxUtilsConfigurationProperties;
import com.kx.utils.id.IdGenerator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
/**
* 雪花算法
*
* @author kongxiang
*/
@Component
public class SnowFlowerIdGenerator implements IdGenerator {
@Autowired
private KxUtilsConfigurationProperties kxUtilsConfigurationProperties;
private long dataCenterId;
private long workerId;
private volatile long sequence;
/**
* 上次时间戳,初始值为负数
*/
private long lastTimestamp = -1L;
/**
* 初始时间戳
*/
private final long twepoch = 1288834974657L;
/**
* 长度为5位
*/
private final long workerIdBits = 5L;
private final long datacenterIdBits = 5L;
/**
* 最大值
*/
private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
/**
* 序列号id长度
*/
private final long sequenceBits = 12L;
/**
* 序列号最大值
*/
private final long sequenceMask = -1L ^ (-1L << sequenceBits);
/**
* 工作id需要左移的位数,12位
*/
private final long workerIdShift = sequenceBits;
/**
* 数据id需要左移位数 12+5=17位
*/
private final long datacenterIdShift = sequenceBits + workerIdBits;
/**
* 时间戳需要左移位数 12+5+5=22位
*/
private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
/**
* 初始化雪花算法 dataCenterId & WorkId
*/
@PostConstruct
public void init() {
KxUtilsConfigurationProperties.SnowFlowerConfig snowFlowerConfig = kxUtilsConfigurationProperties.getId().getSnowFlower();
this.dataCenterId = snowFlowerConfig.getDataCenterId();
this.workerId = snowFlowerConfig.getWorkerId();
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (dataCenterId > maxDatacenterId || dataCenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
System.out.printf("worker starting. timestamp left shift %d, datacenter id bits %d, worker id bits %d, sequence bits %d, workerid %d",
timestampLeftShift, datacenterIdBits, workerIdBits, sequenceBits, workerId);
}
@Override
public String generate() {
return String.valueOf(nextId());
}
@Override
public String getAlgorithm() {
return "snowflower";
}
/**
* 使用一个 64 bit 的 long 型的数字作为全局唯一 id。在分布式系统中的应用十分广泛,且ID 引入了时间戳,基本上保持自增的。
* <p>
* 这 64 个 bit 中,其中 1 个 bit 是不用的(我们生成的 id 都是正数,所以第一个 bit 统一都是 0),
* 然后用其中的 41 bit 作为毫秒数,用 10 bit 作为工作机器 id,12 bit 作为序列号。
* <p>
* 64 bit 的 long 型数字:
* <p>
* 第一个部分,是 1 个 bit:0,这个是无意义的。
* <p>
* 第二个部分是 41 个 bit:表示的是时间戳。
* <p>
* 第三个部分是 5 个 bit:表示的是机房 id,10001。
* <p>
* 第四个部分是 5 个 bit:表示的是机器 id,1 1001。
* <p>
* 第五个部分是 12 个 bit:表示的序号,就是某个机房某台机器上这一毫秒内同时生成的 id 的序号,0000 00000000。
*
* @return
*/
private synchronized long nextId() {
long timestamp = timeGen();
//获取当前时间戳如果小于上次时间戳,则表示时间戳获取出现异常
if (timestamp < lastTimestamp) {
System.err.printf("clock is moving backwards. Rejecting requests until %d.", lastTimestamp);
throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds",
lastTimestamp - timestamp));
}
//获取当前时间戳如果等于上次时间戳(同一毫秒内),则在序列号加一;否则序列号赋值为0,从0开始。
if (lastTimestamp == timestamp) {
sequence = (sequence + 1) & sequenceMask;
if (sequence == 0) {
timestamp = tilNextMillis(lastTimestamp);
}
} else {
sequence = 0;
}
//将上次时间戳值刷新
lastTimestamp = timestamp;
/**
* 返回结果:
* (timestamp - twepoch) << timestampLeftShift) 表示将时间戳减去初始时间戳,再左移相应位数
* (datacenterId << datacenterIdShift) 表示将数据id左移相应位数
* (workerId << workerIdShift) 表示将工作id左移相应位数
* | 是按位或运算符,例如:x | y,只有当x,y都为0的时候结果才为0,其它情况结果都为1。
* 因为个部分只有相应位上的值有意义,其它位上都是0,所以将各部分的值进行 | 运算就能得到最终拼接好的id
*/
return ((timestamp - twepoch) << timestampLeftShift) |
(dataCenterId << datacenterIdShift) |
(workerId << workerIdShift) |
sequence;
}
/**
* 获取系统时间戳
*
* @return
*/
private long timeGen() {
return System.currentTimeMillis();
}
//获取时间戳,并与上次时间戳比较
private long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
}