雪花算法

時間 2019-12-08

標籤雪花算法简体版

原文原文鏈接

關於雪花

雪花(snowflake)在天然界中，是極具獨特美麗，又變幻莫測的東西：git

雪花屬於六方晶系，它具備四個結晶軸，其中三個輔軸在一個基面上，互相以60度的角度相交，第四軸(主晶軸)與三個輔軸所造成的基面垂直；
雪花的基本形狀是六角形，可是大天然中卻幾乎找不出兩朵徹底相同的雪花，每個雪花都擁有本身的獨有圖案，就象地球上找不出兩個徹底相同的人同樣。許多學者用顯微鏡觀測過成千上萬朵雪花，這些研究最後代表，形狀、大小徹底同樣和各部分徹底對稱的雪花，在天然界中是沒法造成的。

雪花算法：

雪花算法的原始版本是scala版，用於生成分佈式ID（純數字，時間順序）,訂單編號等。github

自增ID：對於數據敏感場景不宜使用，且不適合於分佈式場景。
GUID：採用無心義字符串，數據量增大時形成訪問過慢，且不宜排序。golang

算法描述：算法

最高位是符號位，始終爲0，不可用。
41位的時間序列，精確到毫秒級，41位的長度可使用69年。時間位還有一個很重要的做用是能夠根據時間進行排序。
10位的機器標識，10位的長度最多支持部署1024個節點。
12位的計數序列號，序列號即一系列的自增id，能夠支持同一節點同一毫秒生成多個ID序號，12位的計數序列號支持每一個節點每毫秒產生4096個ID序號。

Donet版本

using System;

namespace System
{
    /// <summary>
    /// 分佈式ID算法（雪花算法）
    /// </summary>
    public class Snowflake
    {
        private static long machineId;//機器ID
        private static long datacenterId = 0L;//數據ID
        private static long sequence = 0L;//計數從零開始

        private static long twepoch = 687888001020L; //惟一時間隨機量

        private static long machineIdBits = 5L; //機器碼字節數
        private static long datacenterIdBits = 5L;//數據字節數
        public static long maxMachineId = -1L ^ -1L << (int)machineIdBits; //最大機器ID
        private static long maxDatacenterId = -1L ^ (-1L << (int)datacenterIdBits);//最大數據ID

        private static long sequenceBits = 12L; //計數器字節數，12個字節用來保存計數碼        
        private static long machineIdShift = sequenceBits; //機器碼數據左移位數，就是後面計數器佔用的位數
        private static long datacenterIdShift = sequenceBits + machineIdBits;
        private static long timestampLeftShift = sequenceBits + machineIdBits + datacenterIdBits; //時間戳左移動位數就是機器碼+計數器總字節數+數據字節數
        public static long sequenceMask = -1L ^ -1L << (int)sequenceBits; //一微秒內能夠產生計數，若是達到該值則等到下一微妙在進行生成
        private static long lastTimestamp = -1L;//最後時間戳

        private static object syncRoot = new object();//加鎖對象
        static Snowflake snowflake;

        public static Snowflake Instance()
        {
            if (snowflake == null)
                snowflake = new Snowflake();
            return snowflake;
        }

        public Snowflake()
        {
            Snowflakes(0L, -1);
        }

        public Snowflake(long machineId)
        {
            Snowflakes(machineId, -1);
        }

        public Snowflake(long machineId, long datacenterId)
        {
            Snowflakes(machineId, datacenterId);
        }

        private void Snowflakes(long machineId, long datacenterId)
        {
            if (machineId >= 0)
            {
                if (machineId > maxMachineId)
                {
                    throw new Exception("機器碼ID非法");
                }
                Snowflake.machineId = machineId;
            }
            if (datacenterId >= 0)
            {
                if (datacenterId > maxDatacenterId)
                {
                    throw new Exception("數據中心ID非法");
                }
                Snowflake.datacenterId = datacenterId;
            }
        }

        /// <summary>
        /// 生成當前時間戳
        /// </summary>
        /// <returns>毫秒</returns>
        private static long GetTimestamp()
        {
            return (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
        }

        /// <summary>
        /// 獲取下一微秒時間戳
        /// </summary>
        /// <param name="lastTimestamp"></param>
        /// <returns></returns>
        private static long GetNextTimestamp(long lastTimestamp)
        {
            long timestamp = GetTimestamp();
            if (timestamp <= lastTimestamp)
            {
                timestamp = GetTimestamp();
            }
            return timestamp;
        }

        /// <summary>
        /// 獲取長整型的ID
        /// </summary>
        /// <returns></returns>
        public long GetId()
        {
            lock (syncRoot)
            {
                long timestamp = GetTimestamp();
                if (Snowflake.lastTimestamp == timestamp)
                { //同一微妙中生成ID
                    sequence = (sequence + 1) & sequenceMask; //用&運算計算該微秒內產生的計數是否已經到達上限
                    if (sequence == 0)
                    {
                        //一微妙內產生的ID計數已達上限，等待下一微妙
                        timestamp = GetNextTimestamp(lastTimestamp);
                    }
                }
                else
                {
                    //不一樣微秒生成ID
                    sequence = 0L;
                }
                if (timestamp < lastTimestamp)
                {
                    throw new Exception("時間戳比上一次生成ID時時間戳還小，故異常");
                }
                Snowflake.lastTimestamp = timestamp; //把當前時間戳保存爲最後生成ID的時間戳
                long Id = ((timestamp - twepoch) << (int)timestampLeftShift)
                    | (datacenterId << (int)datacenterIdShift)
                    | (machineId << (int)machineIdShift)
                    | sequence;
                return Id;
            }
        }
    }
}

Golang版

snowflake.goc#

package snowflake
// twitter 雪花算法
// 把時間戳,工做機器ID, 序列號組合成一個 64位 int
// 第一位置零, [2,42]這41位存放時間戳,[43,52]這10位存放機器id,[53,64]最後12位存放序列號

import "time"
var (
    machineID    int64 // 機器 id 佔10位, 十進制範圍是 [ 0, 1023 ]
    sn            int64 // 序列號佔 12 位,十進制範圍是 [ 0, 4095 ]
    lastTimeStamp int64 // 上次的時間戳(毫秒級), 1秒=1000毫秒, 1毫秒=1000微秒,1微秒=1000納秒
)

func init() {
    lastTimeStamp = time.Now().UnixNano() / 1000000
}

func SetMachineId(mid int64) {
    // 把機器 id 左移 12 位,讓出 12 位空間給序列號使用
    machineID = mid << 12
}

func GetSnowflakeId() int64 {
    curTimeStamp := time.Now().UnixNano() / 1000000
    // 同一毫秒
    if curTimeStamp == lastTimeStamp {
        sn++
        // 序列號佔 12 位,十進制範圍是 [ 0, 4095 ]
        if sn > 4095 {
            time.Sleep(time.Millisecond)
            curTimeStamp = time.Now().UnixNano() / 1000000
            lastTimeStamp = curTimeStamp
            sn = 0
        }

        // 取 64 位的二進制數 0000000000 0000000000 0000000000 0001111111111 1111111111 1111111111  1 ( 這裏共 41 個 1 )和時間戳進行並操做
        // 並結果( 右數 )第 42 位必然是 0,  低 41 位也就是時間戳的低 41 位
        rightBinValue := curTimeStamp & 0x1FFFFFFFFFF
        // 機器 id 佔用10位空間,序列號佔用12位空間,因此左移 22 位; 通過上面的並操做,左移後的第 1 位,必然是 0
        rightBinValue <<= 22
        id := rightBinValue | machineID | sn
        return id
    }
    if curTimeStamp > lastTimeStamp {
        sn = 0
        lastTimeStamp = curTimeStamp
        // 取 64 位的二進制數 0000000000 0000000000 0000000000 0001111111111 1111111111 1111111111  1 ( 這裏共 41 個 1 )和時間戳進行並操做
        // 並結果( 右數 )第 42 位必然是 0,  低 41 位也就是時間戳的低 41 位
        rightBinValue := curTimeStamp & 0x1FFFFFFFFFF
        // 機器 id 佔用10位空間,序列號佔用12位空間,因此左移 22 位; 通過上面的並操做,左移後的第 1 位,必然是 0
        rightBinValue <<= 22
        id := rightBinValue | machineID | sn
        return id
    }
    if curTimeStamp < lastTimeStamp {
        return 0
    }
    return 0
}

main.goapp

package main
import (
    "fmt"
    "reflect"
    "snowflake"
    "time"
)

func main() {
    //var ids = []int64{}
    var ids = make([]int64, 0)

    //設置一個機器標識，如IP編碼,防止分佈式機器生成重複碼
    snowflake.SetMachineId(192168100101)

    fmt.Println("start", time.Now().Format("13:04:05"))
    for i := 0; i < 10000000; i++ {
        id := snowflake.GetSnowflakeId()
        ids = append(ids, id)
    }
    fmt.Println("end  ", time.Now().Format("13:04:05"))

    result := Duplicate(ids)
    fmt.Println("去重後數量：", len(result))
    fmt.Println(result[10], result[11], result[12], result[13], result[14])
    fmt.Println(result[9990], result[9991], result[9992], result[9993], result[9994])
}

//去重
func Duplicate(a interface{}) (ret []interface{}) {
    va := reflect.ValueOf(a)
    for i := 0; i < va.Len(); i++ {
        if i > 0 && reflect.DeepEqual(va.Index(i-1).Interface(), va.Index(i).Interface()) {
            continue
        }
        ret = append(ret, va.Index(i).Interface())
    }
    return ret
}