分布式唯一ID生成的几种方案

Posted 零壹技术栈

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了分布式唯一ID生成的几种方案相关的知识，希望对你有一定的参考价值。

前言

在互联网的业务系统中，涉及到各种各样的ID，如在支付系统中就会有支付ID、退款ID等。那一般生成ID都有哪些解决方案呢？特别是在复杂的分布式系统业务场景中，我们应该采用哪种适合自己的解决方案是十分重要的。下面我们一一来列举一下，不一定全部适合，这些解决方案仅供你参考，或许对你有用。


正文

分布式ID的特性

  • 唯一性：确保生成的ID是全网唯一的。

  • 有序递增性：确保生成的ID是对于某个用户或者业务是按一定的数字有序递增的。

  • 高可用性：确保任何时候都能正确的生成ID。

  • 带时间：ID里面包含时间，一眼扫过去就知道哪天的交易。

分布式ID的生成方案

1. UUID

算法的核心思想是结合机器的网卡、当地时间、一个随记数来生成UUID。

  • 优点：本地生成，生成简单，性能好，没有高可用风险

  • 缺点：长度过长，存储冗余，且无序不可读，查询效率低

2. 数据库自增ID

使用数据库的id自增策略，如 mysql 的 auto_increment。并且可以使用两台数据库分别设置不同步长，生成不重复ID的策略来实现高可用。

  • 优点：数据库生成的ID绝对有序，高可用实现方式简单

  • 缺点：需要独立部署数据库实例，成本高，有性能瓶颈

3. 批量生成ID

一次按需批量生成多个ID，每次生成都需要访问数据库，将数据库修改为最大的ID值，并在内存中记录当前值及最大值。

  • 优点：避免了每次生成ID都要访问数据库并带来压力，提高性能

  • 缺点：属于本地生成策略，存在单点故障，服务重启造成ID不连续

4. Redis生成ID

Redis的所有命令操作都是单线程的，本身提供像 incr 和 increby 这样的自增原子命令，所以能保证生成的 ID 肯定是唯一有序的。

  • 优点：不依赖于数据库，灵活方便，且性能优于数据库；数字ID天然排序，对分页或者需要排序的结果很有帮助。

  • 缺点：如果系统中没有Redis，还需要引入新的组件，增加系统复杂度；需要编码和配置的工作量比较大。

考虑到单节点的性能瓶颈，可以使用 Redis 集群来获取更高的吞吐量。假如一个集群中有5台 Redis。可以初始化每台 Redis 的值分别是1, 2, 3, 4, 5，然后步长都是 5。各个 Redis 生成的 ID 为：

 
   
   
 
    
  
    
    
  
  1. A：1, 6, 11, 16, 21
    2. 
  
    
    
  
  2. B：2, 7, 12, 17, 22
    3. 
  
    
    
  
  3. C：3, 8, 13, 18, 23
    4. 
  
    
    
  
  4. D：4, 9, 14, 19, 24
    5. 
  
    
    
  
  5. E：5, 10, 15, 20, 25
    6.

随便负载到哪个机确定好，未来很难做修改。步长和初始值一定需要事先确定。使用 Redis 集群也可以方式单点故障的问题。

另外，比较适合使用 Redis 来生成每天从0开始的流水号。比如订单号 = 日期 + 当日自增长号。可以每天在 Redis 中生成一个 Key ，使用 INCR 进行累加。

5. Twitter的snowflake算法

Twitter 利用 zookeeper 实现了一个全局ID生成的服务 Snowflake：https://github.com/twitter/snowflake



如上图的所示，Twitter 的 Snowflake 算法由下面几部分组成：

  • 1位符号位：

由于 long 类型在 java 中带符号的，最高位为符号位，正数为 0，负数为 1，且实际系统中所使用的ID一般都是正数，所以最高位为 0。

  • 41位时间戳（毫秒级）：

需要注意的是此处的 41 位时间戳并非存储当前时间的时间戳，而是存储时间戳的差值（当前时间戳 - 起始时间戳），这里的起始时间戳一般是ID生成器开始使用的时间戳，由程序来指定，所以41位毫秒时间戳最多可以使用 (1<<41)/(1000x60x60x24x365)=69年。

  • 10位数据机器位：

包括5位数据标识位和5位机器标识位，这10位决定了分布式系统中最多可以部署 1<<10=1024 s个节点。超过这个数量，生成的ID就有可能会冲突。

  • 12位毫秒内的序列：

这 12 位计数支持每个节点每毫秒（同一台机器，同一时刻）最多生成 1<<12=4096个ID

加起来刚好64位，为一个Long型。

  • 优点：高性能，低延迟，按时间有序，一般不会造成ID碰撞

  • 缺点：需要独立的开发和部署，依赖于机器的时钟

简单实现

 
   
   
 
    
  
    
    
  
  1. public class IdWorker {
    2. 
  
    
    
  
  2.     /**
    3. 
  
    
    
  
  3.      * 起始时间戳 2017-04-01
    4. 
  
    
    
  
  4.      */
    5. 
  
    
    
  
  5.     private final long epoch = 1491004800000L;
    6. 
  
    
    
  
  6.     /**
    7. 
  
    
    
  
  7.      * 机器ID所占的位数
    8. 
  
    
    
  
  8.      */
    9. 
  
    
    
  
  9.     private final long workerIdBits = 5L;
    10. 
  
    
    
  
  10.     /**
    11. 
  
    
    
  
  11.      * 数据标识ID所占的位数
    12. 
  
    
    
  
  12.      */
    13. 
  
    
    
  
  13.     private final long dataCenterIdBits = 5L;
    14. 
  
    
    
  
  14.     /**
    15. 
  
    
    
  
  15.      * 支持的最大机器ID,结果是31
    16. 
  
    
    
  
  16.      */
    17. 
  
    
    
  
  17.     private final long maxWorkerId = ~(-1L << workerIdBits);
    18. 
  
    
    
  
  18.     /**
    19. 
  
    
    
  
  19.      * 支持的最大数据标识ID,结果是31
    20. 
  
    
    
  
  20.      */
    21. 
  
    
    
  
  21.     private final long maxDataCenterId = ~(-1 << dataCenterIdBits);
    22. 
  
    
    
  
  22.     /**
    23. 
  
    
    
  
  23.      * 毫秒内序列在id中所占的位数
    24. 
  
    
    
  
  24.      */
    25. 
  
    
    
  
  25.     private final long sequenceBits = 12L;
    26. 
  
    
    
  
  26.     /**
    27. 
  
    
    
  
  27.      * 机器ID向左移12位
    28. 
  
    
    
  
  28.      */
    29. 
  
    
    
  
  29.     private final long workerIdShift = sequenceBits;
    30. 
  
    
    
  
  30.     /**
    31. 
  
    
    
  
  31.      * 数据标识ID向左移17(12+5)位
    32. 
  
    
    
  
  32.      */
    33. 
  
    
    
  
  33.     private final long dataCenterIdShift = sequenceBits + workerIdBits;
    34. 
  
    
    
  
  34.     /**
    35. 
  
    
    
  
  35.      * 时间戳向左移22(12+5+5)位
    36. 
  
    
    
  
  36.      */
    37. 
  
    
    
  
  37.     private final long timestampShift = sequenceBits + workerIdBits + dataCenterIdBits;
    38. 
  
    
    
  
  38.     /**
    39. 
  
    
    
  
  39.      * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
    40. 
  
    
    
  
  40.      */
    41. 
  
    
    
  
  41.     private final long sequenceMask = ~(-1L << sequenceBits);
    42. 
  
    
    
  
  42.     /**
    43. 
  
    
    
  
  43.      * 数据标识ID（0～31）
    44. 
  
    
    
  
  44.      */
    45. 
  
    
    
  
  45.     private long dataCenterId;
    46. 
  
    
    
  
  46.     /**
    47. 
  
    
    
  
  47.      * 机器ID（0～31）
    48. 
  
    
    
  
  48.      */
    49. 
  
    
    
  
  49.     private long workerId;
    50. 
  
    
    
  
  50.     /**
    51. 
  
    
    
  
  51.      * 毫秒内序列（0～4095）
    52. 
  
    
    
  
  52.      */
    53. 
  
    
    
  
  53.     private long sequence;
    54. 
  
    
    
  
  54.     /**
    55. 
  
    
    
  
  55.      * 上次生成ID的时间戳
    56. 
  
    
    
  
  56.      */
    57. 
  
    
    
  
  57.     private long lastTimestamp = -1L;
    58. 
  
    
    
  
    59. 
  
    
    
  
  59.     public IdWorker(long dataCenterId, long workerId) {
    60. 
  
    
    
  
  60.         if (dataCenterId > maxDataCenterId || dataCenterId < 0) {
    61. 
  
    
    
  
  61.             throw new IllegalArgumentException(String.format("dataCenterId can't be greater than %d or less than 0", maxDataCenterId));
    62. 
  
    
    
  
  62.         }
    63. 
  
    
    
  
  63.         if (workerId > maxWorkerId || workerId < 0) {
    64. 
  
    
    
  
  64.             throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
    65. 
  
    
    
  
  65.         }
    66. 
  
    
    
  
  66.         this.dataCenterId = dataCenterId;
    67. 
  
    
    
  
  67.         this.workerId = workerId;
    68. 
  
    
    
  
  68.     }
    69. 
  
    
    
  
    70. 
  
    
    
  
  70.     /**
    71. 
  
    
    
  
  71.      * 获得下一个ID (该方法是线程安全的)
    72. 
  
    
    
  
  72.      * @return snowflakeId
    73. 
  
    
    
  
  73.      */
    74. 
  
    
    
  
  74.     public synchronized long nextId() {
    75. 
  
    
    
  
  75.         long timestamp = timeGen();
    76. 
  
    
    
  
  76.         //如果当前时间小于上一次ID生成的时间戳,说明系统时钟回退过,这个时候应当抛出异常
    77. 
  
    
    
  
  77.         if (timestamp < lastTimestamp) {
    78. 
  
    
    
  
  78.             throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
    79. 
  
    
    
  
  79.         }
    80. 
  
    
    
  
  80.         //如果是同一时间生成的，则进行毫秒内序列
    81. 
  
    
    
  
  81.         if (timestamp == lastTimestamp) {
    82. 
  
    
    
  
  82.             sequence = (sequence + 1) & sequenceMask;
    83. 
  
    
    
  
  83.             //毫秒内序列溢出
    84. 
  
    
    
  
  84.             if (sequence == 0) {
    85. 
  
    
    
  
  85.                 //阻塞到下一个毫秒,获得新的时间戳
    86. 
  
    
    
  
  86.                 timestamp = nextMillis(lastTimestamp);
    87. 
  
    
    
  
  87.             }
    88. 
  
    
    
  
  88.         } else {//时间戳改变，毫秒内序列重置
    89. 
  
    
    
  
  89.             sequence = 0L;
    90. 
  
    
    
  
  90.         }
    91. 
  
    
    
  
  91.         lastTimestamp = timestamp;
    92. 
  
    
    
  
  92.         //移位并通过按位或运算拼到一起组成64位的ID
    93. 
  
    
    
  
  93.         return ((timestamp - epoch) << timestampShift) |
    94. 
  
    
    
  
  94.                 (dataCenterId << dataCenterIdShift) |
    95. 
  
    
    
  
  95.                 (workerId << workerIdShift) |
    96. 
  
    
    
  
  96.                 sequence;
    97. 
  
    
    
  
  97.     }
    98. 
  
    
    
  
    99. 
  
    
    
  
  99.     /**
    100. 
  
    
    
  
  100.      * 返回以毫秒为单位的当前时间
    101. 
  
    
    
  
  101.      * @return 当前时间(毫秒)
    102. 
  
    
    
  
  102.      */
    103. 
  
    
    
  
  103.     protected long timeGen() {
    104. 
  
    
    
  
  104.         return System.currentTimeMillis();
    105. 
  
    
    
  
  105.     }
    106. 
  
    
    
  
    107. 
  
    
    
  
  107.     /**
    108. 
  
    
    
  
  108.      * 阻塞到下一个毫秒，直到获得新的时间戳
    109. 
  
    
    
  
  109.      * @param lastTimestamp 上次生成ID的时间截
    110. 
  
    
    
  
  110.      * @return 当前时间戳
    111. 
  
    
    
  
  111.      */
    112. 
  
    
    
  
  112.     protected long nextMillis(long lastTimestamp) {
    113. 
  
    
    
  
  113.         long timestamp = timeGen();
    114. 
  
    
    
  
  114.         while (timestamp <= lastTimestamp) {
    115. 
  
    
    
  
  115.             timestamp = lastTimestamp;
    116. 
  
    
    
  
  116.         }
    117. 
  
    
    
  
  117.         return timestamp;
    118. 
  
    
    
  
  118.     } 
    119. 
  
    
    
  
  119. }
    120.

6. 百度UidGenerator

UidGenerator是百度开源的分布式ID生成器，基于于snowflake算法的实现，看起来感觉还行。不过，国内开源的项目维护性真是担忧。

具体可以参考官网说明：https://github.com/baidu/uid-generator/blob/master/README.zh_cn.md

7. 美团Leaf

Leaf 是美团开源的分布式ID生成器，能保证全局唯一性、趋势递增、单调递增、信息安全，里面也提到了几种分布式方案的对比，但也需要依赖关系数据库、Zookeeper等中间件。

具体可以参考官网说明：https://tech.meituan.com/MT_Leaf.html

小结

这篇文章和大家分享了全局id生成服务的几种常用方案，同时对比了各自的优缺点和适用场景。在实际工作中，大家可以结合自身业务和系统架构体系进行合理选型。



本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。


以上是关于分布式唯一ID生成的几种方案的主要内容，如果未能解决你的问题，请参考以下文章

text 分布式唯一ID的几种生成方案

分布式唯一ID的几种生成方案

分布式唯一ID生成的几种方案

分布式唯一ID的几种生成方案

游戏服务器生成全局唯一ID的几种方法

游戏服务器生成全局唯一ID的几种方法