服務器有校時情況下的雪花算法改進

最近由於項目需要，要用到雪花算法生成ID，所以到網上找了個java的實現版本

原版代碼如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * Twitter_Snowflake<br>
 * SnowFlake的結構如下(每部分用-分開):<br>
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
 * 1位標識，由於long基本類型在Java中是帶符號的，最高位是符號位，正數是0，負數是1，所以id一般是正數，最高位是0<br>
 * 41位時間截(毫秒級)，注意，41位時間截不是存儲當前時間的時間截，而是存儲時間截的差值（當前時間截 - 開始時間截)
 * 得到的值），這裏的的開始時間截，一般是我們的id生成器開始使用的時間，由我們程序來指定的（如下下面程序IdWorker類的startTime屬性）。41位的時間截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
 * 10位的數據機器位，可以部署在1024個節點，包括5位datacenterId和5位workerId<br>
 * 12位序列，毫秒內的計數，12位的計數順序號支持每個節點每毫秒(同一機器，同一時間截)產生4096個ID序號<br>
 * 加起來剛好64位，爲一個Long型。<br>
 * SnowFlake的優點是，整體上按照時間自增排序，並且整個分佈式系統內不會產生ID碰撞(由數據中心ID和機器ID作區分)，並且效率較高，經測試，SnowFlake每秒能夠產生26萬ID左右。
 */
public class SnowflakeIdWorker {

    private static final Logger logger = LoggerFactory.getLogger(SnowflakeIdWorker.class);

    private static final SnowflakeIdWorker INSTANCE;

    static {
        long workId = 0;
        long dataCenterId = 0;
        try {
            String localHostIpString = HostIpUtils.getLocalHostIpString();
            logger.info("獲取的本機IP爲： "+ localHostIpString);
            String[] array = localHostIpString.split("\\.");
            long sum = 0;
            for (String s : array) {
                sum += Long.parseLong(s);
            }
            long max = 1 << 5;
            dataCenterId = sum / max;
            workId = sum % max;
            logger.info("初始化生成的機房ID:" + dataCenterId + "\t機器ID：" +workId);

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("雪花算法id生成器初始化失敗");
        }
        INSTANCE = new SnowflakeIdWorker(workId, dataCenterId);
    }

    // ==============================Fields===========================================
    /** 開始時間截 (2015-01-01) */
    //TODO 開始時間戳的選擇影響生成的id長度，選取時間越靠前，則生成id越長，最長爲19位，最短爲9位
    private final long twepoch = 1420041600000L;

    /** 機器id所佔的位數 */
    private static final long workerIdBits = 5L;

    /** 數據標識id所佔的位數 */
    private static final long datacenterIdBits = 5L;

    /** 支持的最大機器id，結果是31 (這個移位算法可以很快的計算出幾位二進制數所能表示的最大十進制數) */
    public static final long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /** 支持的最大數據標識id，結果是31 */
    public static final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

    /** 序列在id中佔的位數 */
    private final long sequenceBits = 12L;

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

    /** 數據標識id向左移17位(12+5) */
    private final long datacenterIdShift = sequenceBits + workerIdBits;

    /** 時間截向左移22位(5+5+12) */
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    /** 生成序列的掩碼，這裏爲4095 (0b111111111111=0xfff=4095) */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    /** 工作機器ID(0~31) */
    private long workerId;

    /** 數據中心ID(0~31) */
    private long datacenterId;

    /** 毫秒內序列(0~4095) */
    private long sequence = 0L;

    /** 上次生成ID的時間截 */
    private long lastTimestamp = -1L;

    //==============================Constructors=====================================
    /**
     * 構造函數
     * @param workerId 工作ID (0~31)
     * @param datacenterId 數據中心ID (0~31)
     */
    private SnowflakeIdWorker(long workerId, long datacenterId) {
        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;
    }

    // ==============================Methods==========================================
    /**
     * 獲得下一個ID (該方法是線程安全的)
     * @return SnowflakeId
     */
    public synchronized long nextId() {
        long timestamp = timeGen();

        //如果當前時間小於上一次ID生成的時間戳，說明系統時鐘回退過這個時候應當拋出異常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(
                    String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        //如果是同一時間生成的，則進行毫秒內序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            //毫秒內序列溢出
            if (sequence == 0) {
                //阻塞到下一個毫秒,獲得新的時間戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        //時間戳改變，毫秒內序列重置
        else {
            sequence = 0L;
        }

        //上次生成ID的時間截
        lastTimestamp = timestamp;

        //移位並通過或運算拼到一起組成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (datacenterId << datacenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }

    /**
     * 阻塞到下一個毫秒，直到獲得新的時間戳
     * @param lastTimestamp 上次生成ID的時間截
     * @return 當前時間戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    /**
     * 返回以毫秒爲單位的當前時間
     * @return 當前時間(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }

    public static long getNextLongId() {
        return INSTANCE.nextId();
    }

    public static String getNextId() {
        return INSTANCE.nextId() + "";
    }

    //==============================Test=============================================
    /** 測試 */
    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 1000; i++) {
            long id = getNextLongId();
            System.out.println(Long.toBinaryString(id));
            System.out.println(id);
        }
    }
}

然後要根據項目需要做些改進，首先就是datacenterId和workerId的初始化問題，在網上找了些文章看，最後總結以下三個思路

1、服務器單機算法，通過獲取服務器自身的某些標識來確定workId,但由於生成的workId有兩個基本的要求，其一是唯一性，不能重複，其二是取值範圍0-1023，也就是一共只能有1024個不同值，所以獲取的服務器標識的值必須小於1024種可能，大於的話，由標識映射到workId就不能保證唯一性了，能符合這兩個要求的標識暫時沒有想到，因爲像硬件序列號，爲保證區分不同電腦，基本都有上億以上的取值可能，不能滿足要求，暫時只能想到IP在前三個數固定的同一網段上，能滿足這樣的要求，不過實際的可操作性還要看
2、部署時注入環境變量，這樣部署會比較麻煩，
3、利用第三方服務來實現，例如網上可以找到的用etcd或zk來發號

由於不想部署時麻煩，實際部署時的網段是前兩位固定，所以前兩個思路都被否了，只能用第三個方案，不過項目用的spring cloud構建的微服務，沒有用到zk，倒是用到了redis，所以考慮藉助redis來實現發號

利用redis發號的邏輯大概如下：

雪花算法ID生成器類加載時，先獲取redis的分佈式鎖，沒獲取到，就等待直到獲取到，然後按指定的workId(workerId和datacenterId共十位確定的0-1023範圍內的值)，分配保存的前綴查詢所有在redis分配到的workId，然後找到0-1023範圍內沒被分配的最小的workId號，把這個號拼上前綴保存到redis，有效期一小時，然後設定一個定時任務，每半小時執行一次，把分配到的workId號加固存到redis，避免這個號過期後，再被分配。

這樣workId分配的問題就解決了，然後又遇了新的問題，就是應用部署後需要校時，也就是有一定概率發生時間回調，原算法中發生時間回調後，調用會直接拋異常，這個邏輯顯示不能接受，所以需要改進，之前在網上查看雪花算法時，也看到有應對時間回調的方案，不過我突然自己想到了兩個思路，所以沒有再去網上查其他的方案了，下面是我想到的兩個思路：

方案一是發現時鐘回撥後，算出來回撥多少，保存爲時間偏移量，然後後面每次獲取時間戳都加上偏移量，每回撥一次更新一次偏移量
方案二是，只在第一次生成id或啓動時獲取時間戳並保存下來，每生成一個id，就計下數，每個毫秒數能生成的id數是固定的，到生成滿了，再把時間戳加一，這樣就不依賴於系統時間了，每個毫秒數的使用率也最高

經過一翻考慮，最終採用了方案一，並寫了個demo，demo代碼git庫地址：https://gitee.com/regedit0726/snowflake

demo中寫了單元測試，分別驗證了單線程和多線程，以及多線程併發生時間回調那個情況下的生成ID的唯一性，並各自測算了每秒生成ID數量的效率，在我本地跑測試，單線程大概每秒生成五六十萬個ID，多線程大概三四十萬個ID。

服務器有校時情況下的雪花算法改進

服務器有校時情況下的雪花算法改進

一次JVM內存溢出問題解決記錄

Spring Cloud中FeignClient實現文件上傳功能

mybatis-generator代碼生成與手寫代碼分離實踐

mybatis的mapper繼承實現

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結