前言

分布式ID在多种场景下都有广泛的应用，如分库分表后生成全局用户Id,订单Id,分布式事物中的全局Id,消息队列中的全局消息Id.因此本文分析一下常用的分布式Id的常见实现方案。

SnowFlake-雪花算法

SnowFlake是Twitter最早提出的一种全局ID生成算法，可以产生一个Time-Based的全局ID， 由于生成简单、ID趋势递增，业界采用的比较广泛。比如在snowflake中的64-bit分别表示如下图（图片来自网络）所示：

snowflake-structure.png

41-bit的时间可以表示（1L<<41）/(1000L_3600_24*365)=69年的时间，10-bit机器可以分别表示1024台机器。如果我们对IDC划分有需求，还可以将10-bit分5-bit给IDC，分5-bit给工作机器。这样就可以表示32个IDC，每个IDC下可以有32台机器，可以根据自身需求定义。12个自增序列号可以表示2^12个ID，理论上snowflake方案的QPS约为409.6w/s，这种分配方式可以保证在任何一个IDC的任何一台机器在任意毫秒内生成的ID都是不同的。

SnowFlakeID是一个64 bit，8 bytes的整数类型，结构如下：
bit[0]：最高位填0，保证ID是正整数。
bit[1-41]：时间戳，41 bit。表示自某个起始时间（可自行设定）以来的毫秒数，支持69年跨度。
bit[42-51]：Worker ID，10 bits。表示节点的唯一标识，能同时支持1024个不同的Worker。Worker ID可依赖外部配置中心生成，推荐前5位数据中心ID，后5位PID。
bit[52-63]：并发ID序列号，12 bits。用于同一毫秒内并发产生的ID自增序号，采用原子递增计数器实现，每毫秒重新归0，一毫秒内可以并发产生4096个ID。如果在这个毫秒内生成的数量超过4096，可以阻塞等待到下个毫秒来生成。

这种方式的优缺点

1）本地化生成，算法简单，效率高
2）适合主键字段：时间戳位于ID的高位，毫秒内自增序列在低位，ID趋势递增；长度8个字节，适合数据库存储。
3）不足之处：
3.1）依赖机器时钟，如果时钟错误比如时钟不同步、时钟回拨，会产生重复ID
3.2）每个节点的Worker ID要借助外部服务比如Zookeeper、Redis、MySQL分配
ID容量局限性：时间偏移量支持2^41ms=69年，可以在算法中自定义起始时间，年限略短，一般够用。

Twitter SnowFlake实现

SnowFlake算法用来生成64位的ID，刚好可以用long整型存储，能够用于分布式系统中生产唯一的ID， 并且生成的ID有大致的顺序。 在这次实现中，生成的64位ID可以分成5个部分：
0 - 41位时间戳 - 5位数据中心标识 - 5位机器标识 - 12位序列号
5位数据中心标识跟5位机器标识这样的分配仅仅是当前实现中分配的，如果业务有其实的需要，可以按其它的分配比例分配，如10位机器标识，不需要数据中心标识。

  1. /**
  2.  * twitter的snowflake算法 -- java实现
  3.  * @see @{https://github.com/beyondfengyu/SnowFlake?spm=ata.13261165.0.0.78d12ace8n92XX}
  4.  * @author beyond
  5.  * @date 2016/11/26
  6.  */
  7. public class SnowFlake {
  9.     /**
  10.      * 起始的时间戳
  11.      */
  12.     private final static long START_STMP = 1480166465631L;
  14.     /**
  15.      * 每一部分占用的位数
  16.      */
  17.     private final static long SEQUENCE_BIT = 12; //序列号占用的位数
  18.     private final static long MACHINE_BIT = 5;   //机器标识占用的位数
  19.     private final static long DATACENTER_BIT = 5;//数据中心占用的位数
  21.     /**
  22.      * 每一部分的最大值
  23.      */
  24.     private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);
  25.     private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
  26.     private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);
  28.     /**
  29.      * 每一部分向左的位移
  30.      */
  31.     private final static long MACHINE_LEFT = SEQUENCE_BIT;
  32.     private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
  33.     private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;
  35.     private long datacenterId;  //数据中心
  36.     private long machineId;     //机器标识
  37.     private long sequence = 0L; //序列号
  38.     private long lastStmp = -1L;//上一次时间戳
  40.     public SnowFlake(long datacenterId, long machineId) {
  41.         if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {
  42.             throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");
  43.         }
  44.         if (machineId > MAX_MACHINE_NUM || machineId < 0) {
  45.             throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");
  46.         }
  47.         this.datacenterId = datacenterId;
  48.         this.machineId = machineId;
  49.     }
  51.     /**
  52.      * 产生下一个ID
  53.      *
  54.      * @return
  55.      */
  56.     public synchronized long nextId() {
  57.         long currStmp = getNewstmp();
  58.         if (currStmp < lastStmp) {
  59.             throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
  60.         }
  62.         if (currStmp == lastStmp) {
  63.             //相同毫秒内，序列号自增
  64.             sequence = (sequence + 1) & MAX_SEQUENCE;
  65.             //同一毫秒的序列数已经达到最大
  66.             if (sequence == 0L) {
  67.                 currStmp = getNextMill();
  68.             }
  69.         } else {
  70.             //不同毫秒内，序列号置为0
  71.             sequence = 0L;
  72.         }
  74.         lastStmp = currStmp;
  76.         return (currStmp - START_STMP) << TIMESTMP_LEFT //时间戳部分
  77.             | datacenterId << DATACENTER_LEFT       //数据中心部分
  78.             | machineId << MACHINE_LEFT             //机器标识部分
  79.             | sequence;                             //序列号部分
  80.     }
  82.     private long getNextMill() {
  83.         long mill = getNewstmp();
  84.         while (mill <= lastStmp) {
  85.             mill = getNewstmp();
  86.         }
  87.         return mill;
  88.     }
  90.     private long getNewstmp() {
  91.         return System.currentTimeMillis();
  92.     }
  94.     public static void main(String[] args) {
  95.         SnowFlake snowFlake = new SnowFlake(1<<4, 1<<4);
  97.         for (int i = 0; i < 5; i++) {
  98.             System.out.println(snowFlake.nextId());
  99.         }
  101.     }
  102. }

Java UUID

UUID(Universally Unique IDentifier)是一个全局Id的规范,标准型式包含32个16进制数字，以连字号分为五段，形式为8-4-4-4-12的36个字符.示例如:78f236de-a628-4ea7-9382-b6030fcd8454. 典型实现如下:

  1. for (int i = 0; i < 10; i++) {
  2.     UUID uuid = UUID.randomUUID();
  3.     System.out.println(uuid.toString());
  4. }

优点是：本地生成，性能较好。缺点：不易于存储：UUID太长，16字节128位，通常以36长度的字符串表示，很多场景不适用，无顺序，不利于作DB主键。

数据库批量获取

创建一个sequence表,用name表示序列名称,一般用于某业务，用value表示当前值，程序获取到当前值后在内存里缓存一个区间。区间最大值为配置的步长。关键逻辑为：
1）程序初始化,先根据name查询value,如果不存在则初始化0.
2）调用nextRange时，查询当前value,然后计算一个新value=oldValue+step.
3) 最后update sequence表的value字段为newValue。

单数据库批量获取实现

准备数据库表

  1. CREATE TABLE `sequence` (
  2.     `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  3.     `name` varchar(64) NOT NULL,
  4.     `value` bigint(20) NOT NULL,
  5.      `gmt_modified` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  6.     PRIMARY KEY (`id`),
  7.     UNIQUE KEY `unique_name` (`name`)
  8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

实现代码如下

SequenceRange定义:

  1. /**
  2.  * 定义一个从数据库获取的序列区间
  3.  * 该区间表示从数据库里获取一个起始值,然后加上一个步长
  4.  *
  5.  * @author xiele.xl
  6.  * @date 2020-05-19 18:15
  7.  */
  8. public class SequenceRange {
  10.     /**
  11.      * 最小值
  12.      */
  13.     private final long min;
  15.     /**
  16.      * 区间最大值
  17.      */
  18.     private final long max;
  20.     /**
  21.      * 区间记录值
  22.      */
  23.     private AtomicLong value;
  25.     /**
  26.      * 是否到达最大值
  27.      */
  28.     private volatile boolean over = false;
  30.     public SequenceRange(long min, long max) {
  31.         this.min = min;
  32.         this.max = max;
  34.         this.value = new AtomicLong(min);
  35.     }
  37.     /**
  38.      * 获取递增值
  39.      * @return
  40.      */
  41.     public long getAndIncrement() {
  43.         if (over) {
  44.             return -1;
  45.         }
  47.         long current = value.getAndIncrement();
  49.         if (current > this.max) {
  50.             over = true;
  51.             return -1;
  52.         }
  54.         return current;
  56.     }
  59.     /**
  60.      * Getter method for property <tt>min</tt>.
  61.      *
  62.      * @return property value of min
  63.      */
  64.     public long getMin() {
  65.         return min;
  66.     }
  69.     /**
  70.      * Getter method for property <tt>max</tt>.
  71.      *
  72.      * @return property value of max
  73.      */
  74.     public long getMax() {
  75.         return max;
  76.     }
  79.     /**
  80.      * Getter method for property <tt>over</tt>.
  81.      *
  82.      * @return property value of over
  83.      */
  84.     public boolean isOver() {
  85.         return over;
  86.     }
  88.     /**
  89.      * Setter method for property <tt>over</tt>.
  90.      *
  91.      * @param over value to be assigned to property over
  92.      */
  93.     public void setOver(boolean over) {
  94.         this.over = over;
  95.     }
  96. }

序列服务实现:

  1. /**
  2.  * @author xiele.xl
  3.  * @date 2020-05-19 17:20
  4.  */
  5. public class SimpleBatchSequence implements SequenceService {
  7.     private static final String jdbc_url = "jdbc:mysql://localhost:3306/spring_demo";
  8.     private static final String user = "root";
  9.     private static final String password = "Xiele";
  11.     // 定义可见变量
  12.     private volatile SequenceRange range;
  14.     private static final String DEFAULT_SEQ_NAME = "default";
  16.     private static final String SELECT_SQL = "select value from sequence where name = ?";
  18.     private ReentrantLock lock = new ReentrantLock();
  21.     private DataSource dataSource ;
  23.     public Connection getConnection() throws SQLException {
  24.         return dataSource.getConnection();
  25.     }
  27.     public void init() throws SQLException {
  29.         DruidDataSource ds = new DruidDataSource();
  30.         ds.setUrl(jdbc_url);
  31.         ds.setUsername(user);
  32.         ds.setPassword(password);
  34.         ds.init();
  36.         setDataSource(ds);
  38.         initValue(DEFAULT_SEQ_NAME);
  40.     }
  42.     public void initValue(String name) throws SQLException {
  43.         Connection connection = null;
  44.         PreparedStatement pst = null;
  45.         ResultSet rs = null;
  46.         try {
  48.             connection = getConnection();
  50.             pst = connection.prepareStatement(SELECT_SQL);
  51.             pst.setString(1, name);
  52.             rs = pst.executeQuery();
  53.             int result = 0;
  54.             while (rs.next()) {
  55.                 result++;
  56.             }
  57.             // 不存在插入初始化值
  58.             if (result == 0) {
  59.                 pst = connection.prepareStatement(
  60.                     "insert sequence (`name`,`value`,`gmt_modified`) value (?,?,?)");
  61.                 pst.setString(1, name);
  62.                 pst.setLong(2, 0L);
  63.                 pst.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
  65.                 final int effectedRow = pst.executeUpdate();
  66.                 Assert.state(effectedRow == 1, "insert init value failed");
  67.             }
  69.         } finally {
  70.             closeDbResource(pst, rs, connection);
  71.         }
  72.     }
  74.     /**
  75.      * 获取一个序列区间
  76.      *
  77.      * @param name
  78.      * @return
  79.      * @throws SQLException
  80.      */
  81.     public SequenceRange nextRange(String name) {
  83.         Connection connection = null;
  84.         PreparedStatement pst = null;
  85.         ResultSet rs = null;
  87.         long oldValue = 0L;
  88.         long newValue = 0L;
  90.         // 先取出当前值
  91.         try {
  92.             connection = getConnection();
  94.             pst = connection.prepareStatement(SELECT_SQL);
  95.             pst.setString(1, name);
  96.             rs = pst.executeQuery();
  97.             rs.next();
  98.             oldValue = rs.getLong("value");
  100.             // 校验value的范围
  101.             if (oldValue < 0) {
  102.                 throw new RuntimeException("not expected sequence value " + oldValue);
  103.             }
  105.             if (oldValue > Long.MAX_VALUE) {
  106.                 throw new RuntimeException("sequence value is exceeded max long value");
  107.             }
  109.             newValue = oldValue + getStep();
  111.         } catch (SQLException e) {
  112.             e.printStackTrace();
  113.         } finally {
  114.             closeDbResource(pst, rs, connection);
  115.         }
  117.         // 在更新新值到db里
  118.         try {
  119.             connection = getConnection();
  120.             pst = connection.prepareStatement(
  121.                 "update sequence set value = ?, gmt_modified = ? where name = ? and value = ?");
  122.             pst.setLong(1, newValue);
  123.             pst.setTimestamp(2, new Timestamp(System.currentTimeMillis()));
  124.             pst.setString(3, name);
  125.             pst.setLong(4, oldValue);
  127.             Assert.state(pst.executeUpdate() == 1, "update failed");
  129.         } catch (SQLException e) {
  130.             e.printStackTrace();
  132.         } finally {
  133.             closeDbResource(pst, rs, connection);
  134.         }
  136.         return new SequenceRange(oldValue + 1, newValue);
  138.     }
  140.     @Override
  141.     public long nextValue() {
  142.         if (range == null) {
  143.             lock.lock();
  144.             try {
  145.                 if (range == null) {
  146.                     range = nextRange(DEFAULT_SEQ_NAME);
  147.                     System.err.println(String.format("初次获取Range,线程编号=%s,获取成功", Thread.currentThread().getName()));
  148.                 }
  149.             } finally {
  150.                 lock.unlock();
  151.             }
  152.         }
  154.         long value = range.getAndIncrement();
  155.         // 表示本区间已取完,需要重新从db里拿一个起始值
  156.         // 由于存在多个线程同时来拿,因此只有一个线程可以拿成功
  157.         // 如果多个线程同时拿完了,并发进入==-1，再次加锁,获取下一段。
  158.         if (value == -1) {
  159.             lock.lock();
  160.             try {
  161.                 for (; ; ) {
  162.                     if (range.isOver()) {
  163.                         range = nextRange(DEFAULT_SEQ_NAME);
  164.                         System.err.println(
  165.                             String.format("用完Range,再次获取Range,线程编号=%s,获取成功", Thread.currentThread().getName()));
  166.                     }
  167.                     value = range.getAndIncrement();
  168.                     if (value == -1) {
  169.                         continue;
  170.                     }
  171.                     break;
  172.                 }
  173.             } finally {
  174.                 lock.unlock();
  175.             }
  177.         }
  179.         return value;
  181.     }
  183.     /**
  184.      * 默认步长,可配置
  185.      *
  186.      * @return
  187.      */
  188.     public long getStep() {
  190.         return 1000;
  191.     }
  193.     /**
  194.      * Setter method for property <tt>dataSource</tt>.
  195.      *
  196.      * @param dataSource value to be assigned to property dataSource
  197.      */
  198.     public void setDataSource(DataSource dataSource) {
  199.         this.dataSource = dataSource;
  200.     }
  202.     private void closeDbResource(Statement st, ResultSet rs, Connection conn) {
  203.         closeStatement(st);
  204.         closeResultSet(rs);
  205.         closeConnection(conn);
  206.     }
  208.     private void closeStatement(Statement st) {
  209.         if (st != null) {
  210.             try {
  211.                 st.close();
  212.             } catch (SQLException e) {
  213.                 e.printStackTrace();
  214.             }
  215.         }
  216.     }
  218.     private void closeResultSet(ResultSet rs) {
  219.         if (rs != null) {
  220.             try {
  221.                 rs.close();
  222.             } catch (SQLException e) {
  223.                 e.printStackTrace();
  224.             }
  225.         }
  226.     }
  228.     private void closeConnection(Connection connection) {
  229.         if (connection != null) {
  230.             try {
  231.                 connection.close();
  232.             } catch (SQLException e) {
  233.                 e.printStackTrace();
  234.             }
  235.         }
  236.     }
  238.     public static void main(String[] args) throws SQLException, InterruptedException {
  240.         // 测试case1:单线程测试正确性
  241.         SimpleBatchSequence sequence = new SimpleBatchSequence();
  242.         sequence.init();
  244.         //int count = 1001;
  245.         //while (count-- > 0) {
  246.         //    System.out.println("nextVal: " + sequence.nextValue());
  247.         //}
  249.         // 多线程并发获取:测试并发性
  250.         final int nThreads = 100;
  251.         final ExecutorService executor = Executors.newFixedThreadPool(nThreads);
  253.         CountDownLatch latch = new CountDownLatch(nThreads);
  255.         for (int i = 0; i < nThreads; i++) {
  256.             executor.execute(() -> {
  257.                 int cnt = 10;
  258.                 while (cnt-- > 0) {
  259.                     System.out.println(String
  260.                         .format("currentThreadName:%s. nextVal: %d", Thread.currentThread().getName(),
  261.                             sequence.nextValue()));
  262.                 }
  263.                 latch.countDown();
  265.             });
  266.         }
  268.         latch.await();
  269.         System.out.println("Latch end");
  270.         executor.shutdown();
  271.         System.out.println("executor shutdown");
  272.         System.out.println(executor);
  274.     }
  275. }

多数据库实例的批量获取

实际工程应用中需要构建多数据源集群来保证高可用，可扩展的发号能力。
多数据源要解决的问题同样是各个数据源要确保生成互不重叠的ID序列，即将原来的自然数序列分成若干份互不相交的子等差数列。实现原理如下：把一个大批量ID段（外步长）按数据源分成多个小批量ID段（内步长），每个dataSource每次分配一个内步长的ID段，然后按照外步长跃进；通过这种错位交替分配策略，可以使不同dataSource产生的ID段互不相交。
在这种场景下，有多个db里有相同的Sequence表，涉及到内步长innerStep与外步长outStep。

multi_datasource_step.png

实现代码思路

初始化阶段:

  1. 配置数据库实例数量dsCount，内部长innerStep,默认为1000, 计算外步长outStep=dsCount * innerStep.
  2. 自动调节sequence表：
    如果sequence里无初始值，则分别初始化每个db实例里的初始值。例如:以内步长为1000，dsCount=2为例,则ds1库里Sequence表里的value序列应该为为0，1000.ds2库里Sequence表里的value序列应该为1000,2000
    如果已经存在value,验证当前value是否需要重新需要校正一下。

获取Range阶段

随机从ds里拿取一个value,然后计算一下newValue=value+outStep,在update value为newValue.

group_sequence_next_range.jpg

单一数据库表自增

创建一个Sequence表,用MySQL的自增Id机制来生成序列。采用replace into 语法加select last_insert_id,由于两个sql预计不是原子的，需要包含在一个事物里。

Sequence表结构如下：

  1. CREATE TABLE `sequence` (
  2.   `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  3.   `name` char(8) NOT NULL,
  4.   PRIMARY KEY (`id`),
  5.   UNIQUE KEY `uk_name` (`name`)
  6. ) ENGINE=InnoDB DEFAULT CHARSET=utf8

事物中获取Id的SQL脚本类似如下：

  1. begin;
  2. replace into sequence(`name`) value ('default2');
  3. select last_insert_id();
  4. commit;

注:Mysql可配置自增起始值(@@auto_increment_increment)与步长(@@auto_increment_offset)来控制Id的生成策略,不同的业务可用不同的序列表来控制对应的Id序列。

JDBC实现代码

  1. import java.sql.Connection;
  2. import java.sql.DriverManager;
  3. import java.sql.PreparedStatement;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  7. /**
  8.  * 单一数据库表自增Id实现序列服务
  9.  * 实现思路为：事物中执行replace into && select last_insert_id()
  10.  *
  11.  * @author xiele.xl
  12.  * @date 2020-05-19 11:04
  13.  */
  14. public class SingleSequenceService implements SequenceService {
  16.     private static final String jdbc_url = "jdbc:mysql://localhost:3306/spring_demo";
  17.     private static final String user = "root";
  18.     private static final String password = "Xiele";
  20.     private static ThreadLocal<Connection> localConn = new ThreadLocal<>();
  22.     static {
  23.         try {
  24.             Class.forName("com.mysql.jdbc.Driver");
  25.         } catch (Exception e) {
  26.             throw new RuntimeException("Can't register driver!");
  27.         }
  29.     }
  31.     public static Connection getConnection() {
  33.         try {
  34.             Connection conn = localConn.get();
  35.             if (conn == null) {
  36.                 conn = DriverManager.getConnection(jdbc_url, user, password);
  38.                 localConn.set(conn);
  39.             }
  40.             return conn;
  42.         } catch (Exception e) {
  43.             throw new RuntimeException("can not get connection, e=" + e);
  44.         }
  46.     }
  48.     @Override
  49.     public long nextId() {
  51.         Connection con = getConnection();
  52.         try {
  53.             // 设置事物为非自动提交,并开启事物
  54.             con.setAutoCommit(false);
  55.             final PreparedStatement ps = con.prepareStatement(
  56.                 "replace into `sequence` (name) values ('default')");
  57.             ps.executeUpdate();
  58.             final ResultSet rs = ps.executeQuery("select LAST_INSERT_ID()");
  59.             rs.next();
  60.             long nextId = rs.getLong(1);
  61.             con.commit();
  62.             return nextId;
  64.         } catch (SQLException e) {
  65.             try {
  66.                 con.rollback();
  67.             } catch (SQLException ex) {
  69.             }
  70.             throw new RuntimeException(e);
  71.         }
  73.     }
  75.     public static void main(String[] args) {
  77.         SingleSequenceService uss = new SingleSequenceService();
  78.         for (int i = 0; i < 10; i++) {
  79.             System.out.println(uss.nextId());
  80.         }
  82.     }
  83. }

其他方案

Redis原子命令实现递增

Redis提供一些自增原子命令，可以对KEY的值进行原子的增量操作，把返回值作为新的ID。Redis自增命令有：
INCRBY ：给key对应的value加上1，value必须是数值类型。
INCR ：为key对应的value加上指定的增量值。
HINCRBY ：给HASH key中的field指定的域加上指定的增量值。

方案总结

  1. Redis方案和基于数据库的方案本质是一样的，只是发号源由数据库换成了Redis、事务由Redis的单线程机制来保证；也可以类似数据库批量方式，一次生成一批ID。
  2. Redis的ID是一个64 bit signed integer，容量可以充分保证。
  3. 可以保证ID的趋势递增，适用于主键字段
  4. 不足之处：Redis的AOF、RDB两种持久化方式都无法绝对保证数据不丢失，重启Redis有可能产生重复ID。

Zookeeper顺序节点实现递增

Zookeeper作为分布式协调服务框架，提供多种类型的ZNode来存储数据，其中顺序节点（Sequence Node）可以用来生成单调自增序列。它的机制如下：

在同一个路径中创建任意顺序节点（不需要同名），Zookeeper都会在节点名称中追加一个单调增长的计数值，格式是左补0的10位数字，如：”0000000001”、”0000000002”等
Zookeeper集群能保证多个客户端并发创建顺序节点时，只有一个会争抢成功，保证并发的一致性。
顺序节点可以是持久化的，需要应用自行删除；也可以是临时的，创建该节点的客户端断开后，ZK会自动删除。两种方式都不会影响序列的增长。

方案总结

  1. 操作简单，ID单调递增
  2. ID上限：顺序节点的序号生成是由其父节点维持的一个计数器生成的，计数器是一个4字节的signed整数，因此ID的最大值是2147483647，超出就会溢出。
  3. ZooKeeper只能顺序发号，无法批量创建ID，交易性能存在瓶颈，不适用于高并发的发号场景。

参考

Leaf——美团点评分布式ID生成系统

微信序列号生成器架构设计及演变