雪花算法基本結構

雪花算法

自己看到的較好的博客，記錄一下

基本概念

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。

參考博客 https://blog.csdn.net/lq18050010830/article/details/89845790

算法具體介紹

下面的博客對雪花算法的分析很好，可以從第一篇到第七篇開始看

博客園：https://www.cnblogs.com/guos/p/11357422.html （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) + " 毫秒");
    }

}