什么是全局ID

在分布式系统高并发的情况下，避免在不同的机器上出现重复ID，从而设置一种能够进行唯一标识的ID。

此唯一的全局ID需具备如下特点

• 全局唯一性。最基本的要求，必须是唯一不重复的。
• 趋势递增。尽量使用有序的ID。
• 安全性。设置ID的规则越复杂越好，不让恶意用户轻易破解识别。

全局ID的实现方案

没有完美的实现方案，只有适合自己所处具体业务的方案。

1、利用UUID生成

优点：本地代码生成，实现简单，性能非常好。

缺点：

• 生成后的字符串太长，查询效率非常低，并且占用存储空间大；
• 无序的，不能保证趋势递增。

2、数据库自动递增生成

优点：

• 能够保证唯一性；
• 能够保证趋势递增。

缺点：

• 可用性难以保证，数据库的常见架构是一主多从，读写分离，存在单点故障风险，如果主库挂了，就会出现获取重复ID的情况。

3、Redis生成ID

当数据库生成ID的方案不能满足系统要求时，可以尝试使用Redis来生成ID。因为Redis是单线程的，所以它天生可以保证数据的原子性，生成的ID保障了唯一性。

实现生成全局ID，使用Redis的原子操作INCR和INCRBY，来设置初始值和自增步长，轻松做到趋势增长。

优点：

• 性能优于数据库；
• 使用Redis集群可以防止单点故障的风险。

缺点：

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

5、snowflake(雪花算法)方案生成ID

snowflake是Twitter开源的分布式ID生成算法，结果是一个long类型整数。

snowflake的结构如下，一共64位，每部分用“-”分隔，划分为4部分：

• 第一部分：在Java中long的最高位是符号位，整数是0，负数是1。一般生成的ID为整数，所以为0；
• 第二部分：41位的时间戳部分，精确到毫秒级，存储的是由当前时间戳减去设置的开始时间戳(由我们程序来指定的startTime字段)，得到的时间戳。得到的41位的长度的时间戳可以使用69年；
• 第三部分：10位的节点部分，前5位为机器标识，后5位为数据中心标识，可以部署1024个节点；
• 第四部分：12位的序列号部分，序列号即一系列的自增id，可以支持同一节点同一毫秒生成多个ID序号，12位的计数序列号支持每个节点每毫秒产生4096个ID序号。

用Java实现snowflake(雪花算法)方案生成ID的工具类

/**
 * 工具类：snowflake(雪花算法)方案生成ID
 * @author 杨工
 * @date 2020/7/4 20:35
 */
public class SnowflakeIdWorker {
    /**
     * 开始时间截
     */
    private final long startTime = 1480166465631L;
    /**
     * 机器标识所占的位数，5位
     */
    private final long machineBits = 5L;
    /**
     * 数据中心标识所占的位数，5位
     */
    private final long dataCenterBits = 5L;
    /**
     * 序列号占的位数，12位
     */
    private final long sequenceBits = 12L;
    /**
     * 机器标识部分支持的最大值，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
     */
    private final long maxMachineNum = -1L ^ (-1L << machineBits);
    /**
     * 数据中心标识部分支持的最大值，结果是31
     */
    private final long maxDataCenterNum = -1L ^ (-1L << dataCenterBits);
    /**
     * 序列号部分支持的最大值
     */
    private final long maxSequenceNum = -1L ^ (-1L << sequenceBits);
    /**
     * 数据标识部分向左移17位(12+5)
     */
    private final long dataCenterLeft = sequenceBits + machineBits;
    /**
     * 时间截部分向左移22位(17+5)
     */
    private final long timestampLeft = dataCenterLeft + dataCenterBits;
    /**
     * 机器部分向左移动12位
     */
    private final long machineLeft = sequenceBits;
    /**
     * 机器ID(0~31)
     */
    private long machineId;
    /**
     * 数据中心ID(0~31)
     */
    private long dataCenterId;
    /**
     * 毫秒内序列(0~4095)
     */
    private long sequence = 0L;
    /**
     * 上次生成ID的时间截
     */
    private long lastTimestamp = -1L;

    /**
     * 构造函数
     * @param machineId 机器ID (0~31)
     * @param dataCenterId 数据中心ID (0~31)
     */
    public SnowflakeIdWorker(long machineId, long dataCenterId) {
        if (machineId > maxMachineNum || machineId < 0) {
            throw new IllegalArgumentException(String.format("machineId can't be greater than %d or less than 0", maxMachineNum));
        }
        if (dataCenterId > maxDataCenterNum || dataCenterId < 0) {
            throw new IllegalArgumentException(String.format("dataCenterId can't be greater than %d or less than 0", maxDataCenterNum));
        }
        this.machineId = machineId;
        this.dataCenterId = dataCenterId;
    }

    /**
     * 获得下一个ID (该方法是线程安全的)
     * @return SnowflakeId
     */
    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));
        }
        //如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & maxSequenceNum;
            //毫秒内序列溢出
            if (sequence == 0) {
                //阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        //时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }
        //上次生成ID的时间截
        lastTimestamp = timestamp;
        //移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - startTime) << timestampLeft)
                | (dataCenterId << dataCenterLeft)
                | (machineId << machineLeft)
                | sequence;
    }

    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    /**
     * 返回以毫秒为单位的当前时间
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }
}

测试方法：

public static void main(String[] args) {
    //机器ID和数据中心ID必须唯一，这样就能保证每个节点生成的全局ID是唯一的
    //比如数据中心第2个机房的第10台机器
    SnowflakeIdWorker idWorker = new SnowflakeIdWorker(10, 2);
    for (int i = 0; i < 10; i++) {
        //输出18位long类型的数字
        System.out.println(idWorker.nextId());
    }
}

打印的全局ID如下，这些ID是唯一的，并且是趋势递增的：

476906745114173440
476906745114173441
476906745114173442
476906745114173443
476906745118367744
476906745118367745
476906745118367746
476906745118367747
476906745118367748
476906745118367749

这种方式也是实际开发最常用的分布式全局ID生成方案。请大家参考。

作者：杨工，北京互联网公司在职Java开发，专注分享写作干货。欢迎关注我，期待你的点赞评论。