分布式Id生成-雪花算法（Java）

ゝ一纸荒年。 2023-06-30 12:54 3阅读 0赞

> 最近公司正好在做数据库迁移从oracle到mysql，因为之前oracle主键是使用的 `SYS_GUID ()` 这个oracle提供的函数来生成全球唯一的标识符(原始值)由16个字节组成。可是由于mysql默认使用的InnoDB存储引擎采用的聚簇索引，使用uuid对写性能有一定的影响。而且为了后续分库分表考虑，也不宜采用数据库自增，因此就考虑到需要使用一种可以支持分布式递增且全局唯一的Id生成算法。经过调研，雪花算法是 **Twitter** 开源的一种**生成分布式全局唯一ID**的经典算法，且能保证整体上按照时间递增。

在查看了网上大部分关于雪花算法的资料后，关于雪花算法的解读网上多如牛毛，大多抄来抄去。我发现这些教程大多有两点问题：

1.  只是解读官方算法原理，没有解决 机器ID（5位）和数据中心ID（5位）的配置问题，分布式部署如何保证配置唯一。
2.  都是Demo需要实例化对象，没有形成开箱即用的工具类，不能直接结合项目使用。

**本文旨在完善上面存在的两点问题，希望可以帮助和我一样准备在项目使用 SnowFlake 算法生成数据库主键的小伙伴。**

## 概述 ##

SnowFlake算法生成id的结果是一个64bit大小的整数，它的结构如下图：

![snowflake][]

*  `1位`，不用。二进制中最高位为1的都是负数，但是我们生成的id一般都使用整数，所以这个最高位固定是0
 *  `41位`，用来记录时间戳（毫秒）。
    
     *  41位可以表示个 2 41 2^\{41\} 241 \- 1 个数字。
     *  如果只用来表示正整数（计算机中正数包含0），可以表示的数值范围是：0 至  2 41 − 1 2^\{41\} - 1 241−1 减1是因为可表示的数值范围是从0开始算的，而不是1。
     *  也就是说41位可以表示  2 41 − 1 2^\{41\} - 1 241−1个毫秒的值，转化成单位年则是 2 41 − 1 / ( 1000 ∗ 60 ∗ 60 ∗ 24 ∗ 365 ) = 69 2^\{41\} - 1 /(1000\*60\*60\*24\*365) = 69 241−1/(1000∗60∗60∗24∗365)=69年
 *  `10位`，用来记录工作机器id。
    
     *  可以部署在 2 10 = 1024 2^\{10\} = 1024 210=1024个节点，包括`5位datacenterId`和`5位workerId`
     *  `5位（bit）`可以表示的最大正整数是  2 5 − 1 = 31 2^5-1=31 25−1=31，即可以用0、1、2、3、…31这32个数字，来表示不同的datecenterId或workerId
 *  `12位`，序列号，用来记录同毫秒内产生的不同id。
    
     *  `12位（bit）`可以表示的最大正整数是  2 12 − 1 = 4095 2^\{12\}-1=4095 212−1=4095，即可以用0、1、2、3、…4094这4095个数字，来表示同一机器同一时间截（毫秒)内产生的4095个ID序号。

由于在Java中64bit的整数是long类型，所以在Java中SnowFlake算法生成的id就是long来存储的。

SnowFlake可以保证：

*  所有生成的id按时间趋势递增
 *  整个分布式系统内不会产生重复id（因为有datacenterId和workerId来做区分）

## Talk is cheap, show you the code ##

针对文章开头提出的两个问题，笔者的解决方案是，workId使用服务器IP生成，dataCenterId使用hostName生成，这样可以最大限度防止10位机器码重复，但是由于两个ID都不能超过32，只能取余数，还是难免产生重复，但是实际使用中，hostName和IP的配置一般连续或相近，只要不是刚好相隔32位，就不会有问题，况且，hostName和IP同时相隔32的情况更加是几乎不可能的事，平时做的分布式部署，一般也不会超过100台容器。

上面的方法可以零配置使用雪花算法，雪花算法10位机器码的设定理论上可以有1024个节点，生产上使用docker配置一般是一次编译，然后分布式部署到不同容器，不会有不同的配置。这里提供几种可以完全避免产生重复的方案，可以使用redis自增，在应用启动的时候去获取分配机器码。也可以使用zk下发机器码，将机器对应的机器码存储在zk的永久节点下，每次启动获取。 不过这两种方案都是需要配置开发的，在生产部署机器少以及并发不太大的情况下，使用本文提供的方案即可。后续如果真有问题，会采用这种依赖中间件下发机器码的方案，到时候在进行补充。

完整代码如下：

import org.apache.commons.lang3.RandomUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.net.Inet4Address;
    import java.net.UnknownHostException;
    
    public class SnowflakeIdWorker{ 
    
        private static final Logger LOGGER = LoggerFactory.getLogger(SnowflakeIdWorker.class);
    
        /** 工作机器ID(0~31) */
        private long workerId;
        /** 数据中心ID(0~31) */
        private long dataCenterId;
        /** 毫秒内序列(0~4095) */
        private long sequence = 0L;
    
        public SnowflakeIdWorker(long workerId, long dataCenterId){ 
            // sanity check for workerId
            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));
            }
            LOGGER.info("worker starting. timestamp left shift = {}, dataCenter id bits = {}, worker id bits = {}, sequence bits = {}, workerid = {}, dataCenterId = {}",
                    timestampLeftShift, datacenterIdBits, workerIdBits, sequenceBits, workerId,dataCenterId);
    
            this.workerId = workerId;
            this.dataCenterId = dataCenterId;
        }
    
        /**初始时间戳*/
        private long twepoch = 1577808000000L;
    
        /**长度为5位*/
        private long workerIdBits = 5L;
        private long datacenterIdBits = 5L;
    
        /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
        private long maxWorkerId = -1L ^ (-1L << workerIdBits);
        /** 支持的最大数据标识id，结果是31 */
        private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    
        /** 序列在id中占的位数 */
        private long sequenceBits = 12L;
        /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
        private long sequenceMask = -1L ^ (-1L << sequenceBits);
        
        //工作id需要左移的位数，12位
        private long workerIdShift = sequenceBits;
        //数据id需要左移位数 12+5=17位
        private long datacenterIdShift = sequenceBits + workerIdBits;
        //时间戳需要左移位数 12+5+5=22位
        private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
        
        //上次时间戳，初始值为负数
        private long lastTimestamp = -1L;
    
        private static SnowflakeIdWorker idWorker;
    
        static { 
            idWorker = new SnowflakeIdWorker(getWorkId(),getDataCenterId());
        }
    
        /** * 获得下一个ID (该方法是线程安全的) * @return SnowflakeId */
        public synchronized long nextId() { 
            long timestamp = timeGen();
    
            //获取当前时间戳如果小于上次时间戳，则表示时间戳获取出现异常
            if (timestamp < lastTimestamp) { 
                LOGGER.error("clock is moving backwards. Rejecting requests until : {}.", lastTimestamp);
                throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds",
                        lastTimestamp - timestamp));
            }
    
            //获取当前时间戳如果等于上次时间戳（同一毫秒内），则在序列号加一；否则序列号赋值为0，从0开始。
            if (lastTimestamp == timestamp) { 
                sequence = (sequence + 1) & sequenceMask;
                // 毫秒内序列溢出
                if (sequence == 0) { 
                    timestamp = tilNextMillis(lastTimestamp);
                }
            } else { 
                sequence = 0;
            }
            
            //将上次时间戳值刷新
            lastTimestamp = timestamp;
    
            /** * 返回结果： * (timestamp - twepoch) << timestampLeftShift) 表示将时间戳减去初始时间戳，再左移相应位数 * (datacenterId << datacenterIdShift) 表示将数据id左移相应位数 * (workerId << workerIdShift) 表示将工作id左移相应位数 * | 是按位或运算符，例如：x | y，只有当x，y都为0的时候结果才为0，其它情况结果都为1。 * 因为个部分只有相应位上的值有意义，其它位上都是0，所以将各部分的值进行 | 运算就能得到最终拼接好的id */
            return ((timestamp - twepoch) << timestampLeftShift) |
                    (dataCenterId << datacenterIdShift) |
                    (workerId << workerIdShift) |
                    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();
        }
    
        private static Long getWorkId(){ 
            try { 
                String hostAddress = Inet4Address.getLocalHost().getHostAddress();
                char[] chars = hostAddress.toCharArray();
                int sums = 0;
                for(int b : chars){ 
                    sums += b;
                }
                return (long)(sums % 32);
            } catch (UnknownHostException e) { 
                // 如果获取失败，则使用随机数备用
                return RandomUtils.nextLong(0,31);
            }
        }
    
        private static Long getDataCenterId(){ 
            try { 
                char[] chars = Inet4Address.getLocalHost().getHostName().toCharArray();
    
                int sums = 0;
                for (int i: chars) { 
                    sums += i;
                }
                return (long)(sums % 32);
            } catch (UnknownHostException e) { 
                // 如果获取失败，则使用随机数备用
                return RandomUtils.nextLong(0,31);
            }
    
        }
    
        /** * 静态工具类 * * @return */
        public static Long generateId(){ 
            long id = idWorker.nextId();
            return id;
        }
    
        /** 测试 */
        public static void main(String[] args) { 
            System.out.println(System.currentTimeMillis());
            long startTime = System.nanoTime();
            for (int i = 0; i < 50000; i++) { 
                long id = SnowflakeIdWorker.generateId();
                LOGGER.info("id = {}",id);
            }
            LOGGER.info((System.nanoTime()-startTime)/1000000+"ms");
        }
    
    }

## 扩展 ##

在理解了这个算法之后，其实还有一些扩展的事情可以做：

1.  理论上41位记录时间戳可以表示69年，而时间戳是从1970年开始算，对于现在来说1970到2019这段时间内的毫秒数已经用不上了，因此可以设置一个初始时间参照点（*一般设置为id生成器开始使用的时间*），计算时间戳差值（**当前时间截 - 开始时间截**）。这样就可以扩展时间戳使用的范围。
2.  解密id，由于id的每段都保存了特定的信息，所以拿到一个id，应该可以尝试反推出原始的每个段的信息。反推出的信息可以帮助我们分析。比如作为订单，可以知道该订单的生成日期，负责处理的数据中心等等。
3.  完善算法中生成机器id的策略，进一步采用zk分发或redis自增等，实现完全无碰撞的id生成。
4.  根据自己业务修改每个位段存储的信息。算法是通用的，可以根据自己需求适当调整每段的大小以及存储的信息。

--------------------

**参考资料：**

由于算法中大量采用了位运算，如果不太了解的朋友可以参考这篇解析

[https://segmentfault.com/a/1190000011282426][https_segmentfault.com_a_1190000011282426]

[snowflake]: https://img-blog.csdnimg.cn/20200117164230994.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RhdXJ1c183Yw==,size_16,color_FFFFFF,t_70
[https_segmentfault.com_a_1190000011282426]: https://segmentfault.com/a/1190000011282426