详解分布式系统中的唯一id生成策略

Posted 2021-02-16 javasingle

系统唯一ID是我们在设计一个系统的时候常常会遇见的问题，也常常为这个问题而纠结。生成ID的方法有很多，适应不同的场景、需求以及性能要求。所以有些比较复杂的系统会有多个ID生成的策略。下面就介绍一些常见的ID生成策略。

平常应用中方式很多

1. 数据库自增长序列或字段

2. UUID

3.uuid的变种

4.redis生成

5. Twitter的snowflake算法

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。

本文主要是详解snowflake算法的实现代码解析

  1 /**
  2  * Twitter_Snowflake<br>
  3  * SnowFlake的结构如下(每部分用-分开):<br>
  4  * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
  5  * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
  6  * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
  7  * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的
  8  startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
  9  * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
 10  * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
 11  * 加起来刚好64位，为一个Long型。<br>
 12  * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
 13  */
 14 public class SnowflakeIdWorker {
 15 
 16     // ==============================Fields===========================================
 17     /** 开始时间截 (2015-01-01) */
 18     private final long twepoch = 1420041600000L;
 19 
 20     /** 机器id所占的位数 */
 21     private final long workerIdBits = 5L;
 22 
 23     /** 数据标识id所占的位数 */
 24     private final long datacenterIdBits = 5L;
 25 
 26     /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
 27     private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
 28 
 29     /** 支持的最大数据标识id，结果是31 */
 30     private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
 31 
 32     /** 序列在id中占的位数 */
 33     private final long sequenceBits = 12L;
 34 
 35     /** 机器ID向左移12位 */
 36     private final long workerIdShift = sequenceBits;
 37 
 38     /** 数据标识id向左移17位(12+5) */
 39     private final long datacenterIdShift = sequenceBits + workerIdBits;
 40 
 41     /** 时间截向左移22位(5+5+12) */
 42     private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
 43 
 44     /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
 45     private final long sequenceMask = -1L ^ (-1L << sequenceBits);
 46 
 47     /** 工作机器ID(0~31) */
 48     private long workerId;
 49 
 50     /** 数据中心ID(0~31) */
 51     private long datacenterId;
 52 
 53     /** 毫秒内序列(0~4095) */
 54     private long sequence = 0L;
 55 
 56     /** 上次生成ID的时间截 */
 57     private long lastTimestamp = -1L;
 58 
 59     //==============================Constructors=====================================
 60     /**
 61      * 构造函数
 62      * @param workerId 工作ID (0~31)
 63      * @param datacenterId 数据中心ID (0~31)
 64      */
 65     public SnowflakeIdWorker(long workerId, long datacenterId) {
 66         if (workerId > maxWorkerId || workerId < 0) {
 67             throw new IllegalArgumentException(String.format("worker Id can‘t be greater than %d or less than 0", maxWorkerId));
 68         }
 69         if (datacenterId > maxDatacenterId || datacenterId < 0) {
 70             throw new IllegalArgumentException(String.format("datacenter Id can‘t be greater than %d or less than 0", maxDatacenterId));
 71         }
 72         this.workerId = workerId;
 73         this.datacenterId = datacenterId;
 74     }
 75 
 76     // ==============================Methods==========================================
 77     /**
 78      * 获得下一个ID (该方法是线程安全的)
 79      * @return SnowflakeId
 80      */
 81     public synchronized long nextId() {
 82         long timestamp = timeGen();
 83 
 84         //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
 85         if (timestamp < lastTimestamp) {
 86             throw new RuntimeException(
 87                     String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
 88         }
 89 
 90         //如果是同一时间生成的，则进行毫秒内序列
 91         if (lastTimestamp == timestamp) {
 92             sequence = (sequence + 1) & sequenceMask;
 93             //毫秒内序列溢出
 94             if (sequence == 0) {
 95                 //阻塞到下一个毫秒,获得新的时间戳
 96                 timestamp = tilNextMillis(lastTimestamp);
 97             }
 98         }
 99         //时间戳改变，毫秒内序列重置
100         else {
101             sequence = 0L;
102         }
103 
104         //上次生成ID的时间截
105         lastTimestamp = timestamp;
106 
107         //移位并通过或运算拼到一起组成64位的ID
108         return ((timestamp - twepoch) << timestampLeftShift) //
109                 | (datacenterId << datacenterIdShift) //
110                 | (workerId << workerIdShift) //
111                 | sequence;
112     }
113 
114     /**
115      * 阻塞到下一个毫秒，直到获得新的时间戳
116      * @param lastTimestamp 上次生成ID的时间截
117      * @return 当前时间戳
118      */
119     protected long tilNextMillis(long lastTimestamp) {
120         long timestamp = timeGen();
121         while (timestamp <= lastTimestamp) {
122             timestamp = timeGen();
123         }
124         return timestamp;
125     }
126 
127     /**
128      * 返回以毫秒为单位的当前时间
129      * @return 当前时间(毫秒)
130      */
131     protected long timeGen() {
132         return System.currentTimeMillis();
133     }
134 
135     //==============================Test=============================================
136     /** 测试 */
137     public static void main(String[] args) {
138 //        System.out.println(Long.toBinaryString(5));
139         SnowflakeIdWorker idWorker = new SnowflakeIdWorker(1, 1);
140         for (int i = 0; i < 1000; i++) {
141             long id = idWorker.nextId();
142             System.out.println(Long.toBinaryString(id));
143             System.out.println(id);
144         }
145     }
146 }

附带有直接的测试方法，建议动手可以敲一下看一下其中的原理。

如有问题或者错误烦请指出！