分布式 ID 生成器如何选择？

主键 ID 的分类

• 业务主键：在数据库表中把具有业务逻辑含义的字段作为主键，称为“自然主键(Natural Key)”。例如：身份证号，手机号

• 逻辑主键：在数据库表中采用一个与当前表中逻辑信息无关的字段作为其主键，称为“代理主键”。例如：MySQL的自增 id，Oracle 的序列

• 复合主键：两个或者多个字段的组合作为主键。比如：（id，order_no）

 

下面是几种常见主键 ID 生成方法的优缺点

UUID（字符串）

UUID(Universally Unique Identifier)的标准型式包含32个16进制数字，以“-”连接符分为五段，形式为8-4-4-4-12的36个字符。

• 优点：

全局唯一性，可作为分布式 ID

性能非常高：Java 本地方法生成，无依赖，无网络消耗

• 缺点：

ID 作为数据库表的主键时，UUID 就非常不适用。建议主键要尽量越短越好。

UUID 生成的主键 id 本身无序，建立索引存储空间大，效率低，可能会导致数据位置频繁变动，严重影响索引性能。

UUID 生成的 ID 太长，16 byte128 bit，通常以 36 长度的字符串表示，很多场景不太适用，存储空间大。

自增 ID （序列）

MySQL数据库自增 id（oracle序列）实际使用的场景很多，因为其使用简单方便。

• 优点：

自增 ID（序列）对于表唯一性，如果需要作为分布式系统的 ID，采用不同起始值，相同步长方式自增

性能好，有序性，存储空间小，适合建索引

• 缺点：

依赖数据库本身

自增 ID（序列）可能被用完

不适合分布式系统

Twitter 开源的分布式 ID 生成方案（Long）

由于我们的数据库在生产环境中要分片部署(MyCat)，所以我们不能使用数据库本身的自增功能来产生主键值，只能由程序来生成唯一的主键值。我们采用的是开源的 twitter( 非官方中文惯称：推特，是国外的一个网站，是一个社交网络及微博客服务) 的 snowflake (雪花)算法，即是“1+41+10+12”bit 组合的方式组装 ID 号。

默认情况下 41 bit 的时间戳可以支持该算法使用到 2082 年，10 bit 的工作机器id可以支持 1024 台机器，序列号支持 1 毫秒产生 4096 个自增序列 id。SnowFlake 的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生 ID 碰撞(由数据中心 ID 和机器 ID 作区分)，并且效率较高，经测试，SnowFlake 每秒能够产生 26 万 ID 左右。

实现代码如下：

 package cn.giserway.helloworld.util import java.lang.management.ManagementFactory;import java.net.InetAddress;import java.net.NetworkInterface; /** * <p>名称：IdWorker.java</p> * <p>描述：分布式自增长ID</p> * <pre> *     Twitter的 Snowflake　JAVA实现方案 * </pre> * 核心代码为其IdWorker这个类实现，其原理结构如下，我分别用一个0表示一位，用—分割开部分的作用： * 1||0---0000000000 0000000000 0000000000 0000000000 0 --- 00000 ---00000 ---000000000000 * 在上面的字符串中，第一位为未使用（实际上也可作为long的符号位），接下来的41位为毫秒级时间， * 然后5位datacenter标识位，5位机器ID（并不算标识符，实际是为线程标识）， * 然后12位该毫秒内的当前毫秒内的计数，加起来刚好64位，为一个Long型。 * 这样的好处是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和机器ID作区分）， * 并且效率较高，经测试，snowflake每秒能够产生26万ID左右，完全满足需要。 * <p> * 64位ID (42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加)) * * @author Polim */public class IdWorker {    // 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）    private final static long twepoch = 1288834974657L;    // 机器标识位数    private final static long workerIdBits = 5L;    // 数据中心标识位数    private final static long datacenterIdBits = 5L;    // 机器ID最大值    private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);    // 数据中心ID最大值    private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);    // 毫秒内自增位    private final static long sequenceBits = 12L;    // 机器ID偏左移12位    private final static long workerIdShift = sequenceBits;    // 数据中心ID左移17位    private final static long datacenterIdShift = sequenceBits + workerIdBits;    // 时间毫秒左移22位    private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;     private final static long sequenceMask = -1L ^ (-1L << sequenceBits);    /* 上次生产id时间戳 */    private static long lastTimestamp = -1L;    // 0，并发控制    private long sequence = 0L;     private final long workerId;    // 数据标识id部分    private final long datacenterId;    // 错误码    private final long ERROR_CODE = 9999L;     public IdWorker(){        this.datacenterId = getDatacenterId(maxDatacenterId);        this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);    }    /**     * @param workerId     *            工作机器ID     * @param datacenterId     *            序列号     */    public IdWorker(long workerId, long datacenterId) {        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;    }    /**     * 获取下一个ID     *     * @return     */    public synchronized long nextId() {        long timestamp = timeGen();        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常        if (timestamp < lastTimestamp) {            // throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));            return ERROR_CODE;        }         if (lastTimestamp == timestamp) {            // 当前毫秒内，则+1            sequence = (sequence + 1) & sequenceMask;            if (sequence == 0) {                // 当前毫秒内计数满了，则等待下一秒                timestamp = tilNextMillis(lastTimestamp);            }        } else {            sequence = 0L;        }        lastTimestamp = timestamp;        // ID偏移组合生成最终的ID，并返回64位ID        long nextId = ((timestamp - twepoch) << timestampLeftShift)                | (datacenterId << datacenterIdShift)                | (workerId << workerIdShift) | sequence;         return nextId;    }     /**     * 阻塞到下一个毫秒，直到获得新的时间戳     * @param lastTimestamp 上次生成ID的时间截     * @return 当前时间戳     */    private long tilNextMillis(final long lastTimestamp) {        long timestamp = this.timeGen();        while (timestamp <= lastTimestamp) {            timestamp = this.timeGen();        }        return timestamp;    }     /**     * 返回以毫秒为单位的当前时间     * @return 当前时间(毫秒)     */    private long timeGen() {        return System.currentTimeMillis();    }     /**     * <p>     * 获取 maxWorkerId     * </p>     */    protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {        StringBuffer mpid = new StringBuffer();        mpid.append(datacenterId);        String name = ManagementFactory.getRuntimeMXBean().getName();        if (!name.isEmpty()) {         /*          * GET jvmPid          */            mpid.append(name.split("@")[0]);        }      /*       * MAC + PID 的 hashcode 获取16个低位       */        return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);    }     /**     * <p>     * 数据标识id部分     * </p>     */    protected static long getDatacenterId(long maxDatacenterId) {        long id = 0L;        try {            InetAddress ip = InetAddress.getLocalHost();            NetworkInterface network = NetworkInterface.getByInetAddress(ip);            if (network == null) {                id = 1L;            } else {                byte[] mac = network.getHardwareAddress();                id = ((0x000000FF & (long) mac[mac.length - 1])                        | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;                id = id % (maxDatacenterId + 1);            }        } catch (Exception e) {            // System.out.println(" getDatacenterId: " + e.getMessage());        }        return id;    }  }

• 优点：

有序递增

全局唯一性，可作为分布式 ID

不依赖第三方 jar，本地方法实现，效率非常高

• 缺点：

依赖服务器时间，如果服务器时间回拨，会导致生成的 id 重复或者服务会处于不可用状态。

时间回拨导致生成 ID 失败的解决方案：

1. 可以通过替换 workerId 避免

2. 由于强依赖时钟，对时间的要求比较敏感，在机器工作时 NTP 同步也会造成秒级别的回退，建议可以直接关闭 NTP 同步。

3. 重试机制，等时钟追上即可。代码如下：

while(true) {    // 获取分布式 id    long id = idWorker.nextId();    if（ERROR_CODE.equals(id)）{        continue;    }    break;}

//如果发生时间回拨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 生成策略。作分布式 id 生成策略的优先级：UUID < 自增 ID（序列）< snowflake 算法 ID。

• 从是否依赖第三方系统看：UUID 和 snowflake ID 本身就不依赖，自增 ID（序列）依赖数据库自身特性

• 从是否具有唯一性俩看：UUID 和 snowflake ID 本身就实现了全局唯一，自增 ID（序列）局部唯一（也可以实现全局唯一）

• 从是否高可用、高效：都挺高可用，高效的，数据库自增 ID（序列）依赖数据库的高可用

• 从存储性能来看：snowflake ID 和 自增 ID（序列）相对于 UUID 存储空间小，效率高

• 从主键索引大小和效率来看：snowflake ID 和 自增 ID（序列）相当，UUID 索引相对较大，效率低

综上所述：snowflake 算法生成分布式 ID 是一个不错的选择。

 

——> End <——

# 精彩推荐 #

Spring Boot 快速入门系列（IV）—— 数据操作篇之 MyBatis

Spring Boot 快速入门系列（V）—— 事务管理篇之 @Transactional

Spring Boot 快速入门系列（VI）—— 接口规范篇

我 "在看"，你呢