本文探讨了在分库分表场景下，雪花算法如何解决id生成问题，包括中心数据库自增、不同步长数据库、UUID、Redis和MQ等方法的对比。重点讲述了雪花算法的优势（高效、全局唯一）和缺点（依赖时钟），以及美团Leaf的实践案例和改进策略。
雪花算法——分库分表情况下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台机器
- 如果每部分服务中有一台机器发生了时间回拨，那么就负载均衡访问另一部分的服务。如果另一部分服务还是时间回拨，那么才报错。
扫一扫
1559
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
