雪花算法详解_雪花算法最大值-CSDN博客

本文链接：https://blog.csdn.net/DJYDFT2831djydft/article/details/113315485

一、简介：

雪花算法是Twitter开源的分布式ID生成算法。生成的ID是一个64位的Long类型的数字，是一个全局唯一的ID；当然这64位的全局唯一ID是由时间戳、机器ID、序列号组成的，如果涉及到不同的机房，可以改进下由由时间戳、机房ID、机器ID、序列号组成。具体是如何分配的，如下图所示：

组成部分详解
1、最高位
是符号位，始终为0，因为需要正数；

2、时间戳
第二部分是41位的时间戳，自增的时间戳（毫秒级），最大可以存（2^41 - 1）的毫秒数，差不多可以存69年

注：69年算法

计算机时间是从1970-01-01 00:00:00 000开始，因为我们在东八区，所以+8个小时是：1970-01-01 08:00:00 000

41位：

1970-01-01 08:00:00 000 用二进制表示：00000000000000000000000000000000000000000

最大时间用二进制表示：11111111111111111111111111111111111111111

一年存储的毫秒数：1L * 1000 * 60 * 60 * 24 * 365

Java代码：

public static void main(String[] args) {
        //41位二进制最小值
        String minTimeStampStr = "00000000000000000000000000000000000000000";
        //41位二进制最大值
        String maxTimeStampStr = "11111111111111111111111111111111111111111";
        //转10进制
        long minTimeStamp = new BigInteger(minTimeStampStr, 2).longValue();
        long maxTimeStamp = new BigInteger(maxTimeStampStr, 2).longValue();
        //一年总共多少毫秒
        long oneYearMills = 1L * 1000 * 60 * 60 * 24 * 365;
        //算出最大可以多少年
        System.out.println((maxTimeStamp - minTimeStamp) / oneYearMills);
    }

3、机房ID
第三部分是5位的机房ID，最大支持（2^5 - 1）数的机房ID，最大支持数为：31

4、机器ID
第四部分是5位的机器ID，最大支持（2^5 - 1）数的机器ID，最大支持数为：31

5、序列号
第五部分是12位的序列ID，最大支持（2^12 - 1）的序列号，意思就是同一毫秒内支持4095个id，同一毫秒内可以生成4095个不同的id

二、思路：

我们在生成全局唯一ID的时候，是请求到一个专门生成的ID的主机，请求的时候需要传入我们自己机房ID，机器ID

流程如下：

首先最高位不管，是符号位，始终是0；
然后将高位后面的41设置为当前时间戳 - 初始化时间戳
再将时间戳后面的5位设置为机房ID
再将机房ID后面的5位设置位机器ID
设置最后12位序列号的时候，如果当前同一毫秒内有多个生成请求，那么就通过这12位的序列号来区分；如果序列号超过最大值，那么就等到下一毫秒再生成。

三、实现：

public class MySnowflake {
    /** 开始时间戳 */
    private final long startTimestamp = 1611814618000L;
    /** 机房ID */
    private long roomId;
    /** 机器ID */
    private long workId;
    /** 序列号 */
    private long serialNum;
    /** 机房ID 位长度 */
    private final long roomIdBits = 5L;
    /** 机器ID 位长度 */
    private final long workIdBits = 5L;
    /** 序列号 位长度 */
    private final long serialNumBits = 12L;
    /** 时间戳左移位数 */
    private final long timestampShiftBits = roomIdBits + workIdBits + serialNumBits;
    /** 机房ID左移位数 */
    private final long roomIdShiftBits = workIdBits + serialNumBits;
    /** 机器ID左移位数 */
    private final long workIdShiftBits = serialNumBits;
    /** 机房ID最大值 (-1L ^ (-1L << roomIdBits)) */
    private final long roomIdMax = 31L;
    /** 机器ID最大值 (-1L ^ (-1L << workIdMax)) */
    private final long workIdMax = 31L;
    /** 序列号最大值 (-1L ^ (-1L << serialNumBits)) */
    private final long serialNumMax = 4095L;
    /** 最后一次生成uuid的时间 */
    private long lastTimestamp = -1L;

    public MySnowflake(long roomId, long workId) {
        if (roomId < -1L || roomId > roomIdMax) {
            throw new RuntimeException("机房ID无效!");
        }
        if (workId < -1L || workId > workIdMax) {
            throw new RuntimeException("机器ID无效!");
        }

        this.roomId = roomId;
        this.workId = workId;
    }

    public synchronized long getUUID() {
        long currentTimestamp = System.currentTimeMillis();
        if (currentTimestamp < lastTimestamp) {
            throw new RuntimeException("当前时间戳比上次生成UUID的时间戳小!");
        }
        // 如果同一时刻同时收到另外一个生成请求，序列号就+1
        if (currentTimestamp == lastTimestamp) {
            // 如果累加值大于序列号最大值的时候就变为0,等到下一毫秒再生成
            serialNum = (serialNum + 1) & serialNumMax;
            if (0 == serialNum) {
                while (currentTimestamp <= lastTimestamp) {
                    currentTimestamp = System.currentTimeMillis();
                }
            }
        } else {
            serialNum = 0L;
        }

        lastTimestamp = currentTimestamp;
        long uuid = ((currentTimestamp - startTimestamp) << timestampShiftBits)
                | (roomId << roomIdShiftBits)
                | (workId << workIdShiftBits)
                | serialNum;
        return uuid;
    }

    public static void main(String[] args) {
    	// 机房ID为30，机器ID为30
        MySnowflake snowflake = new MySnowflake(30, 30);
        for (int i = 0; i < 50; i++) {
            System.out.println(snowflake.getUUID());
        }
    }
}

注：

Q1、为什么要设置private final long startTimestamp = 1600758933000L;

A:通过上面的计算，我们已经知道，雪花算法的时间储存最大值只能是69年，如果我们默认的不设置startTimestamp ，那么就等于1970+69=2039年，今年是2021年，也就是说还只能用18年，明显不合适，所以在生成uuid时，currentTimestamp - startTimestamp即是为了在startTimestamp时间的基础上+69年

Q2、currentTimestamp == lastTimestamp怎么理解

A:同一毫秒，同一机房，同一服务，一下子允许的请求上限是serialNumMax(4095)，也就是说同一毫秒内允许生成的序列号最大值是4095，当这一毫秒内又产生了一个请求，那么这个时候serialNum+1=4096，超过了2^12 - 1，利用&运算，4096&4095=0，然后就会进入0 == serialNum的判断，就会执行while循环，直到currentTimestamp>lastTimestamp，也就是下一毫秒，serialNum主要是为了用来区分同一毫秒内的多次请求不能大于4095这个最大值，还有就是任何2^N&(2^N - 1)==0，二进制&运算大家可以了解一下

Q3、uuid的生成规则怎么理解

A、我们先一段一段的来

(currentTimestamp - startTimestamp) << timestampShiftBits：

假设currentTimestamp - startTimestamp=X，那么X左移（5+5+12=22）位即由X变为X 00000(机房的5位) 00000（机器的5位） 000000000000(序列号12位)，是不是很神奇

roomId << roomIdShiftBits：

假设roomId为Y，那么Y左移（5+12=17）位即由Y变为Y 00000（机器的5位） 000000000000(序列号12位)，是不是很神奇

workId << workIdShiftBits：

假设roomId为Z，那么Z左移（12）位即由Z变为Z 000000000000(序列号12位)，是不是很神奇

serialNum：假设serialNum为M

那么((currentTimestamp - startTimestamp) << timestampShiftBits)| (roomId << roomIdShiftBits) | (workId << workIdShiftBits) | serialNum，假设X=Y=Z=M=1，就可以变成

X 00000 00000 000000000000

| Y 00000 000000000000

| Z 000000000000

| M

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

X 0000Y 0000Z 00000000000M（|:全0为0，其余情况都是1）

这样序列号就出来了，就问神奇不神奇

Q4、机房ID最大值 (-1L ^ (-1L << roomIdBits(5)))=31怎么理解

-1L在二进制里面：

原码： 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

反码： 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110

补码(+1)： 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111