雪花算法——分库分表情况下id解决方案
分库分表的情况下id会遇到哪些挑战
在分库分表的情况下,如果不解决id的问题,那么同一个主键id的数据的时候,将会出现多条记录,这样很显然不能保证数据的正确性。
分库分表id的解决方案
低并发情况下,使用中心数据库自增
用一个中心数据库,建一个表,为每一张表建一条记录,记录存的就是当前可取的id值,每取完,值就加1.
优点:
- 获取id全局唯一
- 自增
缺点:
- 高并发不适合
- 中心数据库需要做好安全备份(主从),保证数据安全
- 需要部署新的数据库实例
使用不同步长数据库自增解决。
两台数据库分别设置不同步长,生成不重复ID的策略来实现高可用。这种方式生成的 id 有序,但是需要独立部署数据库实例,成本高,还会有性能瓶颈。
使用UUID
虽然做到了全局唯一,但是缺点很明显
缺点:是字符串类型,太长,对索引不友好。查询效率很低。
使用redis
这个方式有两种
- 每一张表一个redis键值对,取后加1。这种应对并发量稍微低一些的系统
- 如果并发量在高一些,那么使用的就是redis 的 list 模仿队列先进先出,另外单独维护一个线程往这个队列队尾不断的生产id。动态维持一个可以配置的量。大于这个量就不生产id。这个方案等于提前生成id。取的时候取现成的
缺点:
- 需要维护redis,方式二要维护一个线程
使用MQ
生产者生产id,消费者消费id。
优点: 并发量很高
缺点:需要维护MQ
雪花算法
为什么要使用雪花算法
- 使用不需要维护其他任何系统,id由算法(Java代码生成)
- 并发量极高。
- 只要时钟不回拨,id就全局唯一
算法实现
雪花算法生成的Id组成
首位废弃 | 41位时间戳 | 5位机房码 | 5位机器码 | 12位序列号 |
---|---|---|---|---|
0 | 00000011 00001100 01010000 11001010 00110000 0 | 11111 | 11111 | 00000000 0000 |
Java代码实现
/**
* 拿到的id是一个long类型的id
* long的第一位为0,因为二进制里第一个 bit 为如果是 1,那么都是负数,但是我们生成的 id 都是正数,所以第一个 bit 统一都是 0。
*
* @author douz.wangqinjie
* @date 2021-01-28
*/
public class IdWorker {
/**
* 设置一个时间初始值 2^41 - 1 差不多可以用69年
* 这个初始值就是你机器第一次开始使用的时间,产生的时间戳减去这个值,可以让时间戳用的更久,
* 这个值建议你id获取系统什么时候上线的,就用那一天的时间戳
* 下面的时间戳代指的就是 2021-01-28 18:05:16
*/
private static final long TW_EPOCH = 1611828316000L;
/**
* 5位的机器id
*/
private static final long WORKER_ID_BITS = 5L;
/**
* 这个是二进制运算,就是5 bit最多只能有31个数字,也就是说机器id最多只能是32以内
* WORKER_ID_BITS 值是 5L
* -1L << 5L 值是 -32L 二进制表示是 1111111111111111111111111111111111111111111111111111111111100000
* ~(-1L << 5L) 是上一个值取非 那么值为 11111 值为31
*/
private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
/**
* 5位的机房id
*/
private static final long DATA_CENTER_ID_BITS = 5L;
/**
* 这个是一个意思,就是5 bit最多只能有31个数字,机房id最多只能是32以内
* DATA_CENTER_ID_BITS 值是 5L
* -1L << 5L 值是 -32L 二进制表示是 1111111111111111111111111111111111111111111111111111111111100000
* ~(-1L << 5L) 是上一个值取非 那么值为 11111 值为31
*/
private static final long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);
/**
* 每毫秒内产生的id数 2 的 12次方
*/
private static final long SEQUENCE_BITS = 12L;
/**
* 序列号掩码, 这个用来
* SEQUENCE_BITS 值为12
* -1L << SEQUENCE_BITS 值为 -4096 二进制码为 1111111111111111111111111111111111111111111111111111000000000000
* ~(-1L << SEQUENCE_BITS) 上面各位取非 二进制为 111111111111 值为4095
*/
private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);
/***
* 机器id要左移的位数,左移的位数是序列号的位数 12 位
*/
private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;
/**
* 机房id要左移的位数 值为 (序列号的位数 + 机器ID的位数) 17位
*/
private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
/**
* 时间戳左移位数,值是 (序列号位数 + 机器id位数 + 机房id 位数) 22位
*/
private static final long TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;
/**
* 机器ID 2进制5位 32位减掉1位 31个
*/
private final long workerId;
/**
* 机房ID 2进制5位 32位减掉1位 31个
*/
private final long dataCenterId;
/**
* 代表一毫秒内生成的多个id的最新序号 12位 4096 -1 = 4095 个
*/
private long sequence;
/**
* 记录产生时间毫秒数,判断是否是同1毫秒
*/
private long lastTimestamp = -1L;
/**
* IdWorker 构造器
*
* @param workerId 机器id
* @param dataCenterId 机房id
* @param sequence 一毫秒生成多少个 id 的最新序列号
*/
public IdWorker(long workerId, long dataCenterId, long sequence) {
// 校验机器id 不能大于31 不能小于0
if (workerId > MAX_WORKER_ID || workerId < 0) {
throw new IllegalArgumentException(
String.format("worker Id can't be greater than %d or less than 0", MAX_WORKER_ID));
}
// 校验机房id 不能大于31 不能小于0
if (dataCenterId > MAX_DATA_CENTER_ID || dataCenterId < 0) {
throw new IllegalArgumentException(
String.format("dataCenter Id can't be greater than %d or less than 0", MAX_DATA_CENTER_ID));
}
this.workerId = workerId;
this.dataCenterId = dataCenterId;
this.sequence = sequence;
}
/**
* 这个是核心方法,通过调用nextId()方法,让当前这台机器上的snowflake算法程序生成一个全局唯一的id
*
* @return 全局唯一的id
*/
public synchronized long nextId() {
// 这儿就是获取当前时间戳,单位是毫秒
long timestamp = this.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));
}
// 下面是说假设在同一个毫秒内,又发送了一个请求生成一个id
// 这个时候就得把 sequence 序号给递增1,最多就是4096
if (lastTimestamp == timestamp) {
// 这个意思是说一个毫秒内最多只能有4096个数字,无论你传递多少进来,
// 这个位运算保证始终就是在4096这个范围内,避免你自己传递个sequence超过了4096这个范围
// 小于 掩码 就是原来的sequence + 1 ,如果一旦大于 4095 就会从 0 开始
sequence = (sequence + 1) & SEQUENCE_MASK;
//当某一毫秒的时间,产生的id数 超过4095,系统会进入等待,直到下一毫秒,系统继续产生ID
if (sequence == 0) {
timestamp = this.tilNextMillis(lastTimestamp);
}
} else {
sequence = 0;
}
// 这儿记录一下最近一次生成id的时间戳,单位是毫秒
lastTimestamp = timestamp;
// 这儿就是最核心的二进制位运算操作,生成一个64bit的id
// 先将当前时间戳左移,放到41 bit那儿;将机房id左移放到5 bit那儿;将机器id左移放到5 bit那儿;将序号放最后12 bit
// 最后拼接起来成一个64 bit的二进制数字,转换成10进制就是个long型
return ((timestamp - TW_EPOCH) << TIMESTAMP_LEFT_SHIFT) |
(dataCenterId << DATA_CENTER_ID_SHIFT) |
(workerId << WORKER_ID_SHIFT) | sequence;
}
/**
* 当某一毫秒的时间,产生的id数 超过4095,系统会进入等待,直到下一毫秒,系统继续产生ID
*
* @param lastTimestamp 时间戳
* @return ID
*/
private long tilNextMillis(long lastTimestamp) {
// 获取系统当前时间
long timestamp = this.timeGen();
// 如果当前系统时间小于传入的时间戳,那么就一直循环,直到下一毫秒为止
while (timestamp <= lastTimestamp) {
timestamp = this.timeGen();
}
return timestamp;
}
/**
* 获取当前时间戳
*
* @return 当前时间戳
*/
private long timeGen() {
return System.currentTimeMillis();
}
public static void main(String[] args) {
System.out.println(System.currentTimeMillis() - TW_EPOCH);
System.out.println(Long.toBinaryString(67014000000L));
int getIdCount = 10000;
IdWorker worker = new IdWorker(MAX_WORKER_ID, MAX_DATA_CENTER_ID, SEQUENCE_MASK);
for (int i = 0; i < getIdCount; i++) {
long id = worker.nextId();
//System.out.println(id);
//System.out.println(Long.toBinaryString(id));
}
}
}
对于雪花算法的思考
雪花算法的优点
- 毫秒数在高位,自增序列在低位,整个ID都是趋势递增的。
- 不依赖数据库等第三方系统,以服务的方式部署,稳定性更高,生成ID的性能也是非常高的。经过笔者测试,QPS在 408W/s ,如果算法整合进系统,也有百万级的QPS
- 可以根据自身业务特性分配bit位,非常灵活。如:机房号和机器码完全可以换成和业务相关的序列号。时间戳也可以多加位,或者取毫秒数等。
雪花算法的缺点
强依赖机器时钟,如果机器上时钟回拨,会导致发号重复或者服务会处于不可用状态。
看看大厂是如何避免雪花算法的缺点的
美团Leaf
美团处理时间回拨的思路是:
- 如果时间NTP同步造成秒级的时间回退,直接报错。
- 要么在时钟回拨的时候直接不提供服务直接返回ERROR_CODE,等时钟追上即可。
- 如果小于一个可以等待的时间,那么可以等待一段时间,做一次重试。
由于强依赖时钟,对时间的要求比较敏感,在机器工作时NTP同步也会造成秒级别的回退,建议可以直接关闭NTP同步。要么在时钟回拨的时候直接不提供服务直接返回ERROR_CODE,等时钟追上即可。或者做一层重试,然后上报报警系统,更或者是发现有时钟回拨之后自动摘除本身节点并报警
//发生了回拨,此刻时间小于上次发号时间
if (timestamp < lastTimestamp) {
long offset = lastTimestamp - timestamp;
if (offset <= 5) {
try {
//时间偏差大小小于5ms,则等待两倍时间
wait(offset << 1);//wait
timestamp = timeGen();
if (timestamp < lastTimestamp) {
//还是小于,抛异常并上报。
throwClockBackwardsEx(timestamp);
}
} catch (InterruptedException e) {
throw e;
}
} else {
//throw
throwClockBackwardsEx(timestamp);
}
}
//分配ID
美团还使用高并发,高可用,这样的服务它们部署多台,时间使用NTP同步。
个人思考
虽然美团对时间回拨的处理已经比较完美,但是笔直感觉可以从架构上解决一定程度上解决时间回拨的问题
解决方案:
- 雪花服务分为两部分,每部分N台机器
- 如果每部分服务中有一台机器发生了时间回拨,那么就负载均衡访问另一部分的服务。如果另一部分服务还是时间回拨,那么才报错。