雪花算法

自己看到的较好的博客，记录一下

基本概念

SnowFlake 算法，是 Twitter 开源的分布式 id 生成算法。其核心思想就是：使用一个 64 bit 的 long 型的数字作为全局唯一 id

无意义

时间戳

机房ID

机器ID

序号

0

0001100 10111110 10001001 01000111 10100010 00

10001

1 1001

0000 00000000

1bit

41bit

5bit

5bit

12bit

  • 第一个部分，是 1 个 bit：0，这个是无意义的。

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

  • 第二个部分是 41 个 bit：表示的是时间戳。

41 bit 可以表示的数字多达 2^41 - 1，也就是可以标识 2 ^ 41 - 1 个毫秒值，换算成年就是表示 69 年的时间。

  • 第三个部分是 5 个 bit：表示的是机房 id，10001。

5 个 bit 代表机房，id意思就是最多代表 2 ^ 5 个机房（32 个机房）。

  • 第四个部分是 5 个 bit：表示的是机器 id，1 1001。

5 个 bit 代表机器 id，每个机房里可以代表 2 ^ 5 个机器（32 台机器）。

  • 第五个部分是 12 个 bit：表示的序号，就是某个机房某台机器上这一毫秒内同时生成的 id 的序号，0000 00000000。

12 bit 可以代表的最大正整数是 2 ^ 12 - 1 = 4096，也就是说可以用这个 12 bit 代表的数字来区分同一个毫秒内的 4096 个不同的 id。

参考博客

算法具体介绍

下面的博客对雪花算法的分析很好，可以从第一篇到第七篇开始看

博客园： （1-7）

雪花算法中用到的位运算

  • 取反操作 ~
  • 取反后，正整数变成了负整数，负整数变成正整数
  • 取反后，无论原来是整数还是负数，结果都会变成 (n+1) * -1L例如：3L --> -4L；-9L --> 8L；
  • 位运算快速得出 n 位二进制数能表示的最大整数 ~(-1 << n)
  • 3位对应 111 ---> (2^3) -1 ---> ~(-8) ---> ~(-1 << 3) ---> 7
  • 4位对应 1111 ---> (2^4) -1 ---> ~(-16) ---> ~(-1 << 4) ---> 15

可以得出，n位二进制数对应的最大整数是 ~（-1 << n)

  • 不超过最大值的序列递增 &
  • 7转为二进制：0000 0111，无论什么数与其做&运算，结果都是0000 0xxx
  • 15转为二进制： 0000 1111，无论什么数与其做&运算，结果都是0000 xxxx
  • 15 & 16 ---> 0000 1111 & 0001 0000 结果是 0000 0000
  • 15 & 17 ---> 0000 1111 & 0001 0001 结果是 0000 0001

由上可知，超过15以后，就会从0开始重新算。（为什么选15，因为15是4位的二进制的最大值，4位全是1，类似的还可以选7,31,63, ...）

如果要在12位二进制中递增且不超过12位的最大值，可以用 n&4095

因此这种特性正好可以用在毫秒内的序列上：

seq = (seq + 1) & 4095 （保证了位运算始终就是在4096这个范围内）

代码示例

package com.kai.utils;

import java.net.Inet4Address;
import java.net.UnknownHostException;
import java.util.Random;

/**
 * 雪花算法
 *
 * @version v1.0
 * @since 2020/02/21 14:00
 */
public class IdWorker {

    /** 时间部分所占长度 */
    private static final int TIME_LEN = 41;
    /** 数据中心id所占长度 */
    private static final int DATA_LEN = 5;
    /** 机器id所占长度 */
    private static final int WORK_LEN = 5;
    /** 毫秒内存序列所占长度 */
    private static final int SEQ_LEN = 12;

    /** 定义起始时间 2015-01-01 00:00:00 */
    private static final long START_TIME = 14200041600000L;
    /** 上次生成ID的时间戳 */
    private static long LAST_TIME_STAMP = -1L;
    /** 时间部分向左移动的位数 22 */
    private static final int TIME_LEFT_BIT = 64 - 1 - TIME_LEN;

    /** 自动获取数据中心id（可以手动定义0-31之间的数） */
    private static final long DATA_ID = getDataId();
    /** 自动机器id（可以手动定义0-31之间的数） */
    private static final long WORK_ID = getWorkId();
    /** 数据中心id最大值 31 */
    private static final int DATA_MAX_NUM = ~(-1 << DATA_LEN);
    /** 机器id最大值 31 */
    private static final int WORK_MAX_NUM = ~(-1 << WORK_LEN);
    /** 随机获取数据中心id的参数 32 */
    private static final int DATA_RANDOM = DATA_MAX_NUM + 1;
    /** 随机获取机器id的参数 32 */
    private static final int WORK_RANDOM = WORK_MAX_NUM + 1;
    /** 数据中心id左移位数 17 */
    private static final int DATA_LEFT_BIT = TIME_LEFT_BIT - DATA_LEN;
    /** 机器id左移位数 12 */
    private static final int WORK_LEFT_BIT = DATA_LEFT_BIT - WORK_LEN;

    /** 上一次毫秒内存序列值 */
    private static long LAST_SEQ = 0L;
    /** 毫秒内存列的最大值 4095 */
    private static final long SEQ_MAX_NUM = ~(-1 << SEQ_LEN);

    /**
     * 获取字符串S的字节数组，然后将数组的元素相加，对（max+1）取余
     * @param s 本地机器的hostName/hostAddress
     * @param max 机房/机器的id最大值
     * @return
     */
    private static int getHostId(String s, int max) {
        byte[] bytes = s.getBytes();
        int sums = 0;
        for (int b : bytes) {
            sums += b;
        }
        return sums % (max + 1);
    }

    /**
     * 根据 host address 取余， 发送异常就返回 0-31 之间的随机数
     * @return 机器ID
     */
    private static int getWorkId() {
        try {
            return getHostId(Inet4Address.getLocalHost().getHostAddress(), WORK_MAX_NUM);
        } catch (UnknownHostException e) {
            return new Random().nextInt(WORK_RANDOM);
        }
    }

    /**
     * 根据 host name 取余， 发送异常就返回 0-31 之间的随机数
     * @return 机房ID（数据中心ID）
     */
    private static int getDataId() {
        try{
            return getHostId(Inet4Address.getLocalHost().getHostName(), DATA_MAX_NUM);
        }catch(Exception e){
            return new Random().nextInt(DATA_RANDOM);
        }
    }

    /**
     * 获取下一不同毫秒的时间戳
     * @param lastMillis
     * @return 下一毫秒的时间戳
     */
    private static long nextMillis(long lastMillis) {
        long now = System.currentTimeMillis();
        while (now <= lastMillis) {
            now = System.currentTimeMillis();
        }
        return now;
    }

    /**
     * 核心算法，需要加锁保证并发安全
     * @return 返回唯一ID
     */
    public synchronized static long getUUID() {
        long now = System.currentTimeMillis();

        // 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过，此时因抛出异常
        if (now < LAST_TIME_STAMP) {
            throw new RuntimeException(String.format("系统时间错误！ %d 毫秒内拒绝生成雪花ID", START_TIME));
        }

        if (now == LAST_TIME_STAMP) {
            LAST_SEQ = (LAST_SEQ + 1) & SEQ_MAX_NUM;
            if (LAST_SEQ == 0) {
                now = nextMillis(LAST_TIME_STAMP);
            }
        } else {
            LAST_SEQ = 0;
        }

        // 上次生成ID的时间戳
        LAST_TIME_STAMP = now;

        return ((now - START_TIME) << TIME_LEFT_BIT | (DATA_ID << DATA_LEFT_BIT) | (WORK_ID << WORK_LEFT_BIT) | LAST_SEQ);
    }

    /**
     * 主函数测试
     * @param args
     */
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int num = 300000;
        for (int i = 0; i < num; i++) {
            System.out.println(getUUID());
        }
        long end = System.currentTimeMillis();

        System.out.println("共生成 " + num + " 个ID，用时 " + (end - start) + " 毫秒");
    }

}