【SnowFlake】雪花算法（Java版本）

★半岛铁盒

已于 2022-08-08 14:15:29 修改

阅读量1.2w

点赞数 10

分类专栏： Java 文章标签： java 算法分布式生成ID

于 2022-08-03 17:11:39 首次发布

本文链接：https://blog.csdn.net/weixin_47274607/article/details/126141772

版权

Java 专栏收录该内容

26 篇文章

订阅专栏

SnowFlake雪花算法（Java版本）

一、SnowFlake算法
二、代码实现
三、应用场景
四、优缺点
五、分布式生成ID方式

一、SnowFlake算法

雪花算法(Snowflake)是twitter公司内部分布式项目采用的ID生成算法

Snowflake生成的是Long类型的ID，一个Long类型占8个字节，每个字节占8比特，也就是说一个Long类型占64个比特。
Snowflake ID组成结构：正数位(占1比特)+ 时间戳(占41比特)+ 机器ID(占5比特)+ 数据中心(占5比特)+ 自增值(占12比特)，总共64比特组成的一个Long类型。

在这里插入图片描述

第一位：占用1bit，Java中long的最高位是符号位代表正负，正数是0，负数是1，一般生成ID都为正数，所以默认为0。
时间戳：占用41bit，毫秒级的时间，不建议存当前时间戳，而是用(当前时间戳 - 固定开始时间戳)的差值，可以使产生的ID从更小的值开始;41位的时间戳可以使用69年，(1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69年
工作机器id：占用10bit，最多可以容纳1024个节点（可以改造为5位工作中心+5位数据中心，具体如上图第二部分）
序列号：占用12bit，最多可以累加到4095。自增值支持同一毫秒内同一个节点可以生成4096个ID,这个值在同一毫秒同一节点上从0开始不断累加。(最大可以支持单节点差不多四百万的并发量)

SnowFlake可以保证：

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

根据这个算法的逻辑，只需要将这个算法实现出来，封装为一个工具方法，那么各个业务应用可以直接使用该工具方法来获取分布式ID，只需保证每个业务应用有自己的工作机器id即可，而不需要单独去搭建一个获取分布式ID的应用。

二、代码实现

public class SnowFlake {
    // 因为二进制里第一个 bit 为如果是 1，那么都是负数，但是我们生成的 id 都是正数，所以第一个 bit 统一都是 0。

    /**
     * 机器ID  2进制5位
     */
    private long workerId;

    /**
     * 机房ID 2进制5位
     */
    private long datacenterId;

    /**
     * 代表一毫秒内生成的多个id的最新序号  12位，范围从0到4095
     */
    private long sequence;

    /**
     * 设置一个时间初始值(这个用自己业务系统上线的时间)    2^41 - 1   差不多可以用69年
     */
    private long twepoch = 1585644268888L;

    /**
     * 5位的机器id
     */
    private long workerIdBits = 5L;

    /**
     * 5位的机房id
     */
    private long datacenterIdBits = 5L;

    /**
     * 每毫秒内产生的id数 2 的 12次方
     */
    private long sequenceBits = 12L;

    /**
     * 这个是二进制运算，就是5 bit最多只能有31个数字，也就是说机器id最多只能是32以内
     */
    private long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /**
     * 这个是一个意思，就是5 bit最多只能有31个数字，机房id最多只能是32以内
     */
    private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

    /**
     * 机器ID向左移12位
     */
    private long workerIdShift = sequenceBits;

    /**
     * 机房ID向左移17位
     */
    private long datacenterIdShift = sequenceBits + workerIdBits;

    /**
     *时间戳向左移22位
     */
    private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    /**
     * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
     */
    private long sequenceMask = -1L ^ (-1L << sequenceBits);

    /**
     * 上次生成ID的时间截，记录产生时间毫秒数，判断是否是同1毫秒
     */
    private long lastTimestamp = -1L;

    /**
     * 构造函数
     * @param workerId
     * @param datacenterId
     * @param sequence
     */
    public SnowFlake(long workerId, long datacenterId, long sequence){

        // 检查机房id和机器id是否超过最大值，不能小于0
        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;
        this.sequence=sequence;
    }

    /**
     * 这个是核心方法，通过调用nextId()方法，让当前这台机器上的snowflake算法程序生成一个全局唯一的id
     * @return
     */
    public synchronized long nextId(){
        // 获取当前的时间戳，单位是毫秒
        long timestamp=timeGen();

        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp<lastTimestamp){
            System.err.printf("clock is moving backwards. Rejecting requests until %d.",lastTimestamp);
            throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds",lastTimestamp-timestamp));
        }

        // 下面是说假设在同一个毫秒内，又发送了一个请求生成一个id
        // 这个时候就得把seqence序号给递增1，最多就是4096
        if (lastTimestamp == timestamp) {
            // 这个意思是说一个毫秒内最多只能有4096个数字，无论你传递多少进来，
            //这个位运算保证始终就是在4096这个范围内，避免你自己传递个sequence超过了4096这个范围
            sequence = (sequence + 1) & sequenceMask;
            //当某一毫秒的时间，产生的id数 超过4095，系统会进入等待，直到下一毫秒，系统继续产生ID
            if (sequence == 0) {
                // 阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }else{ // 时间戳改变，毫秒内序列重置
            sequence=0;
        }

        //上次生成ID的时间截
        lastTimestamp=timestamp;

        // 这儿就是最核心的二进制位运算操作，生成一个64bit的id
        // 先将当前时间戳左移，放到41 bit那儿；将机房id左移放到5 bit那儿；将机器id左移放到5 bit那儿；将序号放最后12 bit
        // 最后拼接起来成一个64 bit的二进制数字，转换成10进制就是个long型
        return ((timestamp-twepoch)<<timestampLeftShift)|
                (datacenterId<<datacenterIdShift)|
                (workerId<<workerIdShift)|sequence;
    }

    /**
     * 当某一毫秒的时间，产生的id数 超过4095，系统会进入等待，直到下一毫秒，系统继续产生ID
     * @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();
    }

    /**
     * main 测试类
     * @param args
     */
    public static void main(String[] args) {
        SnowFlake worker=new SnowFlake(1,1,1);
        for (int i=0;i<22;i++){
            System.out.println(worker.nextId());
        }
    }
}

产生的唯一序列ID：
309845423537917952
309845423542112256
309845423542112257
309845423542112258
309845423542112259
309845423542112260
309845423542112261
309845423542112262
309845423542112263
309845423542112264
309845423542112265
309845423542112266
309845423542112267
309845423542112268
309845423542112269
309845423542112270
309845423542112271
309845423542112272
309845423542112273
309845423542112274
309845423542112275
309845423542112276

三、应用场景

1.数据库表主键：很多DBA在大型生产应用禁用auto_increment的ID，这时可以选snowflake替代。
2.TraceId：分布式系统追踪，希望用一个ID贯穿所有子系统来追踪分布式交互过程。也有系统产生一个Exception，我们需要对Exception编号等。
3. 摇一摇/抢红包ID：摇一摇的特点是活动促销的时候，短时间内访问特别大，需要一个高性能的ID生成器。

四、优缺点

优点：

ID在内存生成，不依赖于数据库，高性能高可用。
每秒可生成几百万ID，容量大
由于ID呈趋势递增，插入数据库后，使用索引的时候性能较高。

缺点：

依赖于系统时钟的一致性，如果某台机器的系统时钟回拨，有可能造成ID冲突或者ID乱序。
同一台机器的系统时间回拨过，那么有可能出现ID重复的情况

五、分布式生成ID方式

UUID
UUID(Universally Unique Identifier)的标准型式包含32个16进制数字，以连字号分为五段，形式为8-4-4-4-12的36个字符。示例：5f26d8c0-6e09-43cf-9300-6fda1d11985c

优点：
性能非常高，本地生成，没有网络消耗；实现了唯一性。
缺点：
1.无序，无法预测它的生成顺序，不能生成递增有序数字。
2.主键，ID作为主键时在特定环境中会存在一些问题。例如在做DB主键的场景下，UUID就非常不适用。MySQL官方有明确的建议主键要尽量越短越好。
3.索引，B+树索引的分裂。分布式id作为主键，而主键包含索引，mysql的索引是通过B+树实现的，每一次新的UUID数据的插入，为了查询优化，都会对索引底层的B+树进行修改，又因为UUID是无序的，所以每一次UUID数据的插入会对主键底层的B+树进行很大的修改，这样会导致一些中间节点断裂，也会创造出很多不饱和的节点，这样大大降低了数据库的插入操作。

UUID只能保证全局唯一性，不满足后面的趋势递增，单调递增

数据库主键自增
在分布式里面，数据库的自增ID机制主要原理是：数据库自增ID和mysql数据库的replace into实现的。
这里replace into跟insert功能类似，不同点在于：replace into首先尝试插入数据列表中，如果发现表中已经存在此行数据(根据主键或唯一索引判断)则先删除，再插入；否则则可以直接插入新数据。
replace into的含义是插入一条记录，如果表中唯一索引的值遇到冲突，则替换老数据。

优点：
实现了唯一性、趋势递增。
缺点（集群情况）：
1.系统水平拓展比较困难，比如定义好了步长和机器台数之后，如果需要新添加机器怎么做？假设现在只有一台机器发号是1，2，3，4，5(步长=1)，这时候需要扩容一台新机器：将第二台机器的初值设置的比第一台多很多。当扩容机器达到100台呢？就会出现初值设置会非常大。
2.数据库压力还是很大，每次获取id都得读写一次数据库，非常影响性能，不符合分布式ID系统低延迟、高QPS的硬性要求。

我们每次插入的时候，发现都会把原来的数据给替换，并且ID也会增加
这就满足了：递增性、单调性、唯一性
在分布式情况下，并且并发量不多的情况，可以使用这种方案来解决，获得一个全局的唯一ID

Redis

单机版
因为Redis是单线程的，天生就能够保证原子性，可以使用原子操作INCR和INCRBY来实现。
集群分布式
Redis集群可以获取更高的吞吐量。
注意：
在Redis集群情况下，同样和MySQL一样需要设置不同的增长步长，同时key一定要设置有效期，可以使用Redis集群来获取更高的吞吐量。
假如一个集群有Redis，可以初始化每台Redis的值分别为1，2，3，4，5，然后步长都是5：
各个Redis生成的ID为：
A：1，6，11，16，21
B：2，7，12，17，22
C：3，8，13，18，23
D：4，9，14，19，24
E：5，10，15，20，25
缺点：需要额外配置和维护Redis集群等工作才能获得id，比较麻烦。

雪花算法

优点
1.毫秒数在高维，自增序列在低位，整个ID都是趋势递增的
2.不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID的性能也是非常高的
3.可以根据自身业务特性分配bit位，非常灵活
缺点
1.依赖机器时钟，如果机器时钟回拨，会导致重复ID生成
2.在单机上是递增的，但由于涉及到分布式环境，每台机器上的时钟不可能完全同步，有时候会出现不是全局递增的情况，此缺点可以认为无所谓，一般分布式ID只要求趋势递增，并不会严格要求递增，90%的需求只要求趋势递增。

其它补充：
为了解决时钟回拨问题，导致ID重复，后面有人专门提出了解决的方案