分布式Snowflake雪花算法

 前言

項目中主鍵ID生成方式比較多，但是哪種方式更能提高的我們的工作效率、項目質量、代碼實用性以及健壯性呢，下面作了一下比較，目前雪花算法的優點還是很明顯的。

 

優缺點比較

• UUID（缺點：太長、沒法排序、使數據庫性能降低）
• Redis（缺點：必須依賴Redis）
• Oracle序列號（缺點：用Oracle才能使用）
• Snowflake雪花算法，優點：生成有順序的id，提高數據庫的性能

 

Snowflake雪花算法解析

 

雪花算法解析 結構 snowflake的結構如下(每部分用-分開):
0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
第一位為未使用，接下來的41位為毫秒級時間(41位的長度可以使用69年)，

然后是5位datacenterId和5位workerId(10位的長度最多支持部署1024個節點） ，

最后12位是毫秒內的計數（12位的計數順序號支持每個節點每毫秒產生4096個ID序號）

一共加起來剛好64位，為一個Long型。(轉換成字符串長度為18)。

Snowflake算法核心把時間戳，工作機器id，序列號組合在一起。

整體上按照時間自增排序，並且整個分布式系統內不會產生ID碰撞（由datacenter和機器ID作區分），

並且效率較高，經測試，snowflake每秒能夠產生26萬ID左右，完全滿足需要。

 

分布式Snowflake雪花算法代碼

public class SnowFlakeGenerator {
 
    public static class Factory {
        /**
         * 每一部分占用位數的默認值
         */
        private final static int DEFAULT_MACHINE_BIT_NUM = 5;   //機器標識占用的位數
        private final static int DEFAULT_IDC_BIT_NUM = 5;//數據中心占用的位數
 
        private int machineBitNum;
        private int idcBitNum;
 
        public Factory() {
            this.idcBitNum = DEFAULT_IDC_BIT_NUM;
            this.machineBitNum = DEFAULT_MACHINE_BIT_NUM;
        }
 
        public Factory(int machineBitNum, int idcBitNum) {
            this.idcBitNum = idcBitNum;
            this.machineBitNum = machineBitNum;
        }
 
        public SnowFlakeGenerator create(long idcId, long machineId) {
            return new SnowFlakeGenerator(this.idcBitNum, this.machineBitNum, idcId, machineId);
        }
    }
 
    /**
     * 起始的時間戳
     * 作者寫代碼時的時間戳
     */
    private final static long START_STAMP = 1508143349995L;
 
    /**
     * 可分配的位數
     */
    private final static int REMAIN_BIT_NUM = 22;
 
    /**
     * idc編號
     */
    private long idcId;
 
    /**
     * 機器編號
     */
    private long machineId;
 
    /**
     * 當前序列號
     */
    private long sequence = 0L;
 
    /**
     * 上次最新時間戳
     */
    private long lastStamp = -1L;
 
    /**
     * idc偏移量：一次計算出，避免重復計算
     */
    private int idcBitLeftOffset;
 
    /**
     * 機器id偏移量：一次計算出，避免重復計算
     */
    private int machineBitLeftOffset;
 
    /**
     * 時間戳偏移量：一次計算出，避免重復計算
     */
    private int timestampBitLeftOffset;
 
    /**
     * 最大序列值：一次計算出，避免重復計算
     */
    private int maxSequenceValue;
 
    private SnowFlakeGenerator(int idcBitNum, int machineBitNum, long idcId, long machineId) {
        int sequenceBitNum = REMAIN_BIT_NUM - idcBitNum - machineBitNum;
 
        if (idcBitNum <= 0 || machineBitNum <= 0 || sequenceBitNum <= 0) {
            throw new IllegalArgumentException("error bit number");
        }
 
        this.maxSequenceValue = ~(-1 << sequenceBitNum);
 
        machineBitLeftOffset = sequenceBitNum;
        idcBitLeftOffset = idcBitNum + sequenceBitNum;
        timestampBitLeftOffset = idcBitNum + machineBitNum + sequenceBitNum;
 
        this.idcId = idcId;
        this.machineId = machineId;
    }
 
    /**
     * 產生下一個ID
     */
    public synchronized long nextId() {
        long currentStamp = getTimeMill();
        if (currentStamp < lastStamp) {
            throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastStamp - currentStamp));
        }
 
        //新的毫秒，序列從0開始，否則序列自增
        if (currentStamp == lastStamp) {
            sequence = (sequence + 1) & this.maxSequenceValue;
            if (sequence == 0L) {
                //Twitter源代碼中的邏輯是循環，直到下一個毫秒
                lastStamp = tilNextMillis();
//                throw new IllegalStateException("sequence over flow");
            }
        } else {
            sequence = 0L;
        }
 
        lastStamp = currentStamp;
 
        return (currentStamp - START_STAMP) << timestampBitLeftOffset | idcId << idcBitLeftOffset | machineId << machineBitLeftOffset | sequence;
    }
 
    private long getTimeMill() {
        return System.currentTimeMillis();
    }
 
    private long tilNextMillis() {
        long timestamp = getTimeMill();
        while (timestamp <= lastStamp) {
            timestamp = getTimeMill();
        }
        return timestamp;
    }
}