[转]分布式id生成器:推特「雪花算法」最优解

2022-09-14 25点热度 0人点赞 0条评论

分布式 id 生成器

在分布式场景中,唯一 id 的生成算比较重要。

而通常在高并发场景中,需要类似 MySQL 自增 id 一样不断增长且又不会重复的 id,即 MySql 的主键 id。

比如,在电商 618 或者双 11 搞活动的时候,一般在 0 点 开始,会有千万到亿级的订单量写入,每秒大概需要处理 10 万加的订单。

而在将订单插入数据库之前,我们在业务上需要给订单一个唯一的 id,即利用 idMaker 生存唯一的订单号,再插入数据库内。如果生成的 id 是随机且没有含义的纯数字的话,在大订单量的情况下,对数据库进行增删改查时就不能起到提高效率的作用。所以 此 id 应该应该包含一些时间信息,机器信息等,这样即使后端的系统对消息进行了分库分表,也能够以时间顺序对这些消息进行排序了。

比较典型的就是推特的【雪花算法】了,在以上场景下可以算是最优解,原理如图:

首先确定的是,id 数值长度是 64 位,int64 类型,除去开头的符号位 unused ,其它可以分为四个部分:

  • 41 位来表示收到请求时的时间戳,单位为毫秒
  • 5 位表示数据中心的 id
  • 5 位表求机器的实例 id
  • 12 位为循环自增 id,到达 1111,1111,1111 后来就会 0

以上机制原理生成的 id,可以支持一台机器在一毫秒内能够产生 4096 条消息。也就是一秒共 409.6w 条消息。单单从值域上来讲是完全够用。

数据中心 id 加上实例 id 共有 10 位,每个数据中心可以部署 32 台实例,搭建 32 个数据中心,所以可以一共部署 1024 台实例。

而 41 位的时间戳(毫秒为单位)能够使用 69 年。

下面我们简单看看这个 SnowFlake 算法的一个代码实现,这就是个示例,大家如果理解了这个意思之后,以后可以自己尝试改造这个算法。

总之就是用一个 64 bit 的数字中各个 bit 位来设置不同的标志位,区分每一个 id。

SnowFlake 算法的实现代码如下:

public class IdWorker {
 //因为二进制里第一个 bit 为如果是 1,那么都是负数,但是我们生成的 id 都是正数,所以第一个 bit 统一都是 0。
 //机器ID  2进制5位  32位减掉1位 31个
 private long workerId;
 //机房ID 2进制5位  32位减掉1位 31个
 private long datacenterId;
 //代表一毫秒内生成的多个id的最新序号  12位 4096 -1 = 4095 个
 private long sequence;
 //设置一个时间初始值    2^41 - 1   差不多可以用69年
 private long twepoch = 1585644268888L;
 //5位的机器id
 private long workerIdBits = 5L;
 //5位的机房id
 private long datacenterIdBits = 5L;
 //每毫秒内产生的id数 2 的 12次方
 private long sequenceBits = 12L;
 // 这个是二进制运算,就是5 bit最多只能有31个数字,也就是说机器id最多只能是32以内
 private long maxWorkerId = -1L ^ (-1L << workerIdBits);
 // 这个是一个意思,就是5 bit最多只能有31个数字,机房id最多只能是32以内
 private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
 private long workerIdShift = sequenceBits;
 private long datacenterIdShift = sequenceBits + workerIdBits;
 private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
 private long sequenceMask = -1L ^ (-1L << sequenceBits);
 //记录产生时间毫秒数,判断是否是同1毫秒
 private long lastTimestamp = -1L;
 public long getWorkerId(){
  return workerId;
 }
 public long getDatacenterId() {
  return datacenterId;
 }
 public long getTimestamp() {
  return System.currentTimeMillis();
 }
 public IdWorker(long workerId, long datacenterId, long sequence) {
  // 检查机房id和机器id是否超过31 不能小于0
  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));
  }
  this.workerId = workerId;
  this.datacenterId = datacenterId;
  this.sequence = sequence;
 }
 // 这个是核心方法,通过调用nextId()方法,让当前这台机器上的snowflake算法程序生成一个全局唯一的id
 public 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));
  }
  // 下面是说假设在同一个毫秒内,又发送了一个请求生成一个id
  // 这个时候就得把seqence序号给递增1,最多就是4096
  if (lastTimestamp == timestamp) {
   // 这个意思是说一个毫秒内最多只能有4096个数字,无论你传递多少进来,
   //这个位运算保证始终就是在4096这个范围内,避免你自己传递个sequence超过了4096这个范围
   sequence = (sequence + 1) & sequenceMask;
   //当某一毫秒的时间,产生的id数 超过4095,系统会进入等待,直到下一毫秒,系统继续产生ID
   if (sequence == 0) {
    timestamp = 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 - twepoch) << timestampLeftShift) |
    (datacenterId << datacenterIdShift) |
    (workerId << workerIdShift) | sequence;
 }
 /**
  * 当某一毫秒的时间,产生的id数 超过4095,系统会进入等待,直到下一毫秒,系统继续产生ID
  * @param lastTimestamp
  * @return
  */
 private long tilNextMillis(long lastTimestamp) {
  long timestamp = timeGen();
  while (timestamp <= lastTimestamp) {
   timestamp = timeGen();
  }
  return timestamp;
 }
 //获取当前时间戳
 private long timeGen(){
  return System.currentTimeMillis();
 }
 /**
  *  main 测试类
  * @param args
  */
 public static void main(String[] args) {
  System.out.println(1&4596);
  System.out.println(2&4596);
  System.out.println(6&4596);
  System.out.println(6&4596);
  System.out.println(6&4596);
  System.out.println(6&4596);
//  IdWorker worker = new IdWorker(1,1,1);
//  for (int i = 0; i < 22; i++) {
//   System.out.println(worker.nextId());
//  }
 }
}

SnowFlake算法的优点:

(1)高性能高可用:生成时不依赖于数据库,完全在内存中生成。

(2)容量大:每秒中能生成数百万的自增ID。

(3)ID自增:存入数据库中,索引效率高。

SnowFlake算法的缺点:

依赖与系统时间的一致性,如果系统时间被回调,或者改变,可能会造成id冲突或者重复。

实际中我们的机房并没有那么多,我们可以改进改算法,将10bit的机器id优化,成业务表或者和我们系统相关的业务。

admin

这个人很懒,什么都没留下

文章评论

您需要 登录 之后才可以评论