分布式ID的生成方式

男娘i 2023-06-02 07:53 25阅读 0赞

推荐使用 Twitter 公司开源的 snowflake 算法。

# 一、分布式ID #

在复杂分布式系统中，往往需要对大量的数据和消息进行唯一标识。比如在金融、电商、支付、等产品的系统中，数据日渐增长，对数据分库分表后需要有一个唯一ID来标识一条数据或消息，数据库的自增ID显然不能满足需求，此时一个能够生成全局唯一ID的系统是非常必要的。

#### 分布式id的特点 ####

1.  全局性唯一：不能出现重复的ID号，既然是唯一标识，这是最基本的要求。
2.  单调递增：多数RDBMS使用B-tree的数据结构来存储索引数据，在主键的选择上面应该尽量使用有序的主键保证写入性能。
3.  支持高性能：除了对分布式ID码自身的要求，分布式ID生成需支持高QPS，高可用。
4.  信息安全：如果ID是连续的，恶意用户的抓取工作就非常简单了，直接按照顺序下载指定URL即可；如果是订单号就更危险了，竞对可以直接知道一天的单量。所以在一些应用场景下，会需要ID无规则、不规则。

# 二、分布式ID生成方案 #

1.  Sequence ID
2.  UUID
3.  snowflake算法(着重介绍)

# 三、Sequence ID #

Sequence ID 是数据库自增长序列或字段，最常见的方式。由数据库维护，数据库唯一。

#### 1、优点 ####

1.  简单，代码方便，性能可以接受。
2.  数字ID天然排序，对分页或者需要排序的结果很有帮助。
3.  ID号单调自增，可以实现一些对ID有特殊要求的业务。

#### 2、缺点 ####

1.  不同数据库语法和实现不同，数据库迁移的时候或多数据库版本支持的时候需要处理。
2.  在单个数据库或读写分离或一主多从的情况下，只有一个主库可以生成。有单点故障的风险。
3.  在性能达不到要求的情况下，比较难于扩展。
4.  强依赖DB，当DB异常时整个系统不可用，属于致命问题。配置主从复制可以尽可能的增加可用性，但是数据一致性在特殊情况下难以保证。主从切换时的不一致可能会导致重复发号。

# 四、UUID #

UUID 是通用唯一识别码（Universally Unique Identifier)的缩写，开放软件基金会(OSF)规范定义了包括网卡MAC地址、时间戳、名字空间（Namespace）、随机或伪随机数、时序等元素。利用这些元素来生成UUID。

UUID是由128位二进制组成，一般转换成十六进制，然后用String表示。在 java 的 UUID 工具类(java.util.UUID)注释中可以看见有4种不同的UUID的生成策略:

*
     * <p> The version field holds a value that describes the type of this {@code
     * UUID}.  There are four different basic types of UUIDs: time-based, DCE
     * security, name-based, and randomly generated UUIDs.  These types have a
     * version value of 1, 2, 3 and 4, respectively.
     *

1.  randomly : 基于随机数生成UUID，由于Java中的随机数是伪随机数，其重复的概率是可以被计算出来的。
2.  time-based : 基于时间的UUID,这个一般是通过当前时间，随机数，和本地Mac地址来计算出来，自带的JDK包并没有这个算法的。
3.  DCE security : DCE安全的UUID。
4.  name-based : 基于名字的UUID，通过计算名字和名字空间的MD5来计算UUID。

#### 优点 ####

性能非常高：本地生成，没有网络消耗。

#### 缺点 ####

1.  不易于存储：UUID太长，16字节128位，通常以36长度的字符串表示，很多场景不适用。
2.  信息不安全：基于MAC地址生成UUID的算法可能会造成MAC地址泄露，这个漏洞曾被用于寻找梅丽莎病毒的制作者位置。
3.  ID作为主键时在特定的环境会存在一些问题，比如做DB主键的场景下，UUID就非常不适用：MySQL官方有明确的建议主键要尽量越短越好，36个字符长度的UUID不符合要求。

#### 适用场景 ####

UUID的适用场景可以为不需要担心过多的空间占用，以及不需要生成有递增趋势的数字。在Log4j里面他在UuidPatternConverter中加入了UUID来标识每一条日志。链路ID可以用。

# 五、snowflake算法 #

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

snowflake 算法生成的ID结构 :

![snowflake组成][snowflake]

1.  1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
2.  41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)得到的值），这里的的开始时间截，一般是id生成器开始使用的时间，由程序来指定的。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L \* 60 \* 60 \* 24 \* 365) = 69
3.  10位的数据机器位，可以部署在1024个节点，包括5位 datacenterId 和5位 workerId
4.  12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号

#### 优点 ####

1.  生成ID时不依赖于DB，完全在内存生成，高性能高可用。
2.  整体上按照时间自增排序，ID呈趋势递增，后续插入索引树的时候性能较好。
3.  整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)
4.  效率较高

#### 缺点 ####

在单机上是递增的，但是由于涉及到分布式环境，每台机器上的时钟不可能完全同步，也许有时候也会出现不是全局递增的情况。

如果某台机器的系统时钟回拨，有可能造成ID冲突，或者ID乱序

# 六、Java 实现 snowflake 算法 #

import lombok.extern.slf4j.Slf4j;
    
    /**
     * java 实现 snowflake 算法
     *
     * @author xiaohe
     * @version V1.0.0
     */
    @Slf4j
    public class JavaDemo {
    
        /**
         * 开始时间截 (2019-08-06)
         */
        private static final long TWEPOCH = 1565020800000L;
    
        /**
         * 机器id所占的位数
         */
        private static final long WORKER_ID_BITS = 5L;
    
        /**
         * 数据标识id所占的位数
         */
        private static final long DATA_CENTER_ID_BITS = 5L;
    
        /**
         * 支持的最大机器id，0~31，一共32个 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
         */
        private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
    
        /**
         * 支持的最大数据标识id，结果是31
         */
        private static final long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);
    
        /**
         * 序列在id中占的位数
         */
        private static final long SEQUENCE_BITS = 12L;
    
        /**
         * 机器ID向左移12位
         */
        private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;
    
        /**
         * 数据标识id向左移17位(12+5)
         */
        private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
    
        /**
         * 时间截向左移22位(5+5+12)
         */
        private static final long TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;
    
        /**
         * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
         */
        private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);
    
        /**
         * 工作机器ID(0~31)
         */
        private long workerId;
    
        /**
         * 数据中心ID(0~31)
         */
        private long dataCenterId;
    
        /**
         * 毫秒内序列(0~4095)
         */
        private long sequence = 0L;
    
        /**
         * 上次生成ID的时间截
         */
        private long lastTimestamp = -1L;
    
        /**
         * 构造函数
         *
         * @param workerId     工作ID (0~31)
         * @param dataCenterId 数据中心ID (0~31)
         */
        private JavaDemo(long workerId, long dataCenterId) {
            if (workerId > MAX_WORKER_ID || workerId < 0) {
                throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", MAX_WORKER_ID));
            }
            if (dataCenterId > MAX_DATA_CENTER_ID || dataCenterId < 0) {
                throw new IllegalArgumentException(String.format("dataCenterId Id can't be greater than %d or less than 0", MAX_DATA_CENTER_ID));
            }
            this.workerId = workerId;
            this.dataCenterId = dataCenterId;
        }
    
        /**
         * 获得下一个ID (该方法是线程安全的)
         *
         * @return SnowflakeId
         */
        private 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) & SEQUENCE_MASK;
                //毫秒内序列溢出
                if (sequence == 0) {
                    //阻塞到下一个毫秒,获得新的时间戳
                    timestamp = tilNextMillis(lastTimestamp);
                }
            }
            //时间戳改变，毫秒内序列重置
            else {
                sequence = 0L;
            }
    
            //上次生成ID的时间截
            lastTimestamp = timestamp;
    
            //移位并通过或运算拼到一起组成64位的ID
            return ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT)
                    | (dataCenterId << DATA_CENTER_ID_SHIFT)
                    | (workerId << WORKER_ID_SHIFT)
                    | sequence;
        }
    
        /**
         * 阻塞到下一个毫秒，直到获得新的时间戳
         *
         * @param lastTimestamp 上次生成ID的时间截
         *
         * @return 当前时间戳
         */
        private long tilNextMillis(long lastTimestamp) {
            long timestamp = timeGen();
            while (timestamp <= lastTimestamp) {
                timestamp = timeGen();
            }
            return timestamp;
        }
    
        /**
         * 返回以毫秒为单位的当前时间
         *
         * @return 当前时间(毫秒)
         */
        private long timeGen() {
            return System.currentTimeMillis();
        }
    
        /**
         * 测试
         */
        public static void main(String[] args) {
            JavaDemo idWorker = new JavaDemo(0, 0);
            int loopTime = 1000;
            for (int i = 0; i < loopTime; i++) {
                long id = idWorker.nextId();
                log.info("binary id : [{}]", Long.toBinaryString(id));
                log.info("id : [{}]", id);
            }
    
        }
    }

# 七、maven 工具实现 snowflake 算法 #

maven 中加入依赖：

<dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-captcha</artifactId>
                <version>4.6.7</version>
            </dependency>

使用

import cn.hutool.core.date.DatePattern;
    import cn.hutool.core.date.DateTime;
    import cn.hutool.core.lang.ObjectId;
    import cn.hutool.core.lang.Snowflake;
    import cn.hutool.core.net.NetUtil;
    import cn.hutool.core.util.IdUtil;
    import cn.hutool.core.util.RandomUtil;
    import lombok.extern.slf4j.Slf4j;
    
    import javax.annotation.PostConstruct;
    
    /**
     * ID 生成器
     *
     * @author xiaohe
     * @version V1.0.0
     */
    @Slf4j
    public class IdGenerator {
    
        private long workerId = 0;
    
        @PostConstruct
        void init() {
            try {
                workerId = NetUtil.ipv4ToLong(NetUtil.getLocalhostStr());
                log.info("当前机器 workerId: {}", workerId);
            } catch (Exception e) {
                log.warn("获取机器 ID 失败", e);
                workerId = NetUtil.getLocalhost().hashCode();
                log.info("当前机器 workerId: {}", workerId);
            }
        }
    
        /**
         * 获取一个批次号，形如 2019071015301361000101237
         * <p>
         * 数据库使用 char(25) 存储
         *
         * @param tenantId 租户ID，5 位
         * @param module   业务模块ID，2 位
         *
         * @return 返回批次号
         */
        public synchronized String batchId(int tenantId, int module) {
            String prefix = DateTime.now().toString(DatePattern.PURE_DATETIME_MS_PATTERN);
            return prefix + tenantId + module + RandomUtil.randomNumbers(3);
        }
    
        @Deprecated
        public synchronized String getBatchId(int tenantId, int module) {
            return batchId(tenantId, module);
        }
    
        /**
         * 生成的是不带-的字符串，类似于：b17f24ff026d40949c85a24f4f375d42
         *
         * @return
         */
        public String simpleUUID() {
            return IdUtil.simpleUUID();
        }
    
        /**
         * 生成的UUID是带-的字符串，类似于：a5c8a5e8-df2b-4706-bea4-08d0939410e3
         *
         * @return
         */
        public String randomUUID() {
            return IdUtil.randomUUID();
        }
    
        private Snowflake snowflake = IdUtil.createSnowflake(workerId, 1);
    
        public synchronized long snowflakeId() {
            return snowflake.nextId();
        }
    
        public synchronized long snowflakeId(long workerId, long dataCenterId) {
            Snowflake snowflake = IdUtil.createSnowflake(workerId, dataCenterId);
            return snowflake.nextId();
        }
    
        /**
         * 生成类似：5b9e306a4df4f8c54a39fb0c
         * <p>
         * ObjectId 是 MongoDB 数据库的一种唯一 ID 生成策略，
         * 是 UUID version1 的变种，详细介绍可见：服务化框架－分布式 Unique ID 的生成方法一览。
         *
         * @return
         */
        public String objectId() {
            return ObjectId.next();
        }
    
    }

github地址：[https://github.com/ChaseDreamBoy/generate-distributed-id-demo][https_github.com_ChaseDreamBoy_generate-distributed-id-demo]

[snowflake]: /images/20230601/ca5cab328db044bcb83d2e9663558855.png
[https_github.com_ChaseDreamBoy_generate-distributed-id-demo]: https://github.com/ChaseDreamBoy/generate-distributed-id-demo