算法概述

分佈式系統中，有一些須要使用全局惟一ID的場景，這種時候爲了防止ID衝突能夠使用36位的UUID，可是UUID有一些缺點，首先他相對比較長，另外UUID通常是無序的。有些時候咱們但願能使用一種簡單一些的ID，而且但願ID可以按照時間有序生成。而twitter的snowflake解決了這種需求，最初Twitter把存儲系統從MySQL遷移到Cassandra，由於Cassandra沒有順序ID生成機制，因此開發了這樣一套全局惟一ID生成服務。html

該項目地址（Scala實現）：https://github.com/twitter/snowflake
python版項目地址：https://github.com/erans/pysnowflake
python

ID結構

Snowflake生成的是Long類型的ID，一個Long類型佔8個字節，每一個字節佔8比特，也就是說一個Long類型佔64個比特。git

snowflake的結構以下(每部分用-分開):github

注：上圖的工做機器id（10比特）=數據中心（佔左5比特）+ 機器ID（佔右5比特）面試

Snowflake ID組成結構：正數位（佔1比特）+ 時間戳（佔41比特）+ 數據中心（佔5比特）+ 機器ID（佔5比特）+ 自增值（佔12比特）算法

第一位爲未使用，接下來的41位爲毫秒級時間(41位的長度能夠使用69年)，而後是5位datacenterId和5位workerId(10位的長度最多支持部署1024個節點），最後12位是毫秒內的計數（12位的計數順序號支持每一個節點每毫秒產生4096個ID序號）一共加起來恰好64位，爲一個Long型(轉換成字符串長度爲18)。segmentfault

1bit：不使用。多線程

由於二進制中最高位是符號位，1表示負數，0表示正數。生成的id通常都是用整數，因此最高位固定爲0。

41bit-時間戳：用來記錄時間戳，毫秒級。less

41位能夠表示個毫秒的值。
轉化成單位年則是年。

10bit-工做機器id：用來記錄工做機器id。分佈式

能夠部署在個節點，包含5位datacenterId和5位workerId
5位（bit）能夠表示的最大正整數是，便可以用0、一、二、三、....31這32個數字，來表示不一樣的datecenterId或workerId

12bit-序列號：序列號，用來記錄同毫秒內產生的不一樣id。

12位（bit）能夠表示的最大正整數是，便可以用0、一、二、三、....4094這4095個數字，來表示同一機器同一時間截（毫秒)內產生的4095個ID序號。

算法特性

SnowFlake能夠保證：

全部生成的id按時間趨勢遞增

整個分佈式系統內不會產生重複id（由於有datacenterId和workerId來作區分）

聽說：snowflake每秒可以產生26萬個ID。

算法代碼（C#）

網上雪花算法的C#實現代碼一大把，但大可能是複製的同一份代碼。並且，網上的C#版實現有不少錯誤。
這裏要提一下雪花算法(Snowflake)C#版本壓測Id重複嚴重，爲這位博主默哀一下...
這裏的算法實現代碼是我參考原版（Scala實現）、Java版的代碼用C#實現的，經測試未發現問題，可放心使用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.Remoting.Contexts;
using System.Runtime.CompilerServices;

namespace SnowflakeDemo
{
    public sealed class IdWorker
    {        
        /// <summary>
        /// 起始的時間戳:惟一時間，這是一個避免重複的隨機量，自行設定不要大於當前時間戳。
        /// 一個計時週期表示一百納秒，即一千萬分之一秒。 1 毫秒內有 10,000 個計時週期，即 1 秒內有 1,000 萬個計時週期。
        /// </summary>
        private static long StartTimeStamp = new DateTime(2020,7,1).Ticks/10000;

        /*
         * 每一部分佔用的位數
         * 對於移位運算符 << 和 >>，右側操做數的類型必須爲 int，或具備預約義隱式數值轉換 爲 int 的類型。
         */
        private const int SequenceBit = 12;   //序列號佔用的位數
        private const int MachingBit = 5;     //機器標識佔用的位數
        private const int DataCenterBit = 5; //數據中心佔用的位數

        /*
         * 每一部分的最大值
         */
        private static long MaxSequence = -1L ^ (-1L << SequenceBit);
        private static long MaxMachingNum = -1L ^ (-1L << MachingBit);
        private static long MaxDataCenterNum = -1L ^ (-1L << DataCenterBit);

        /*
         * 每一部分向左的位移
         */
        private const int MachingLeft = SequenceBit;
        private const int DataCenterLeft = SequenceBit + MachingBit;
        private const int TimeStampLeft = DataCenterLeft + DataCenterBit;

        private long dataCenterId;  //數據中心
        private long machineId;     //機器標識
        private long sequence; //序列號
        private long lastTimeStamp = -1;  //上一次時間戳

        private long GetNextMill()
        {
            long mill = getNewTimeStamp();
            while (mill <= lastTimeStamp)
            {
                mill = getNewTimeStamp();
            }
            return mill;
        }

        private long getNewTimeStamp()
        {
            return DateTime.Now.Ticks/10000;            
        }

        /// <summary>
        /// 根據指定的數據中心ID和機器標誌ID生成指定的序列號
        /// </summary>
        /// <param name="dataCenterId">數據中心ID</param>
        /// <param name="machineId">機器標誌ID</param>
        public IdWorker(long dataCenterId, long machineId)
        {
            if (dataCenterId > MaxDataCenterNum || dataCenterId < 0)
            {                
                throw new ArgumentException("DtaCenterId can't be greater than MAX_DATA_CENTER_NUM or less than 0！");
            }
            if (machineId > MaxMachingNum || machineId < 0)
            {
                throw new ArgumentException("MachineId can't be greater than MAX_MACHINE_NUM or less than 0！");
            }
            this.dataCenterId = dataCenterId;
            this.machineId = machineId;
        }

        /// <summary>
        /// 產生下一個ID
        /// </summary>
        /// <returns></returns>
        [MethodImplAttribute(MethodImplOptions.Synchronized)]
        public long NextId()
        {
            long currTimeStamp = getNewTimeStamp();
            if (currTimeStamp < lastTimeStamp)
            {
                //若是當前時間戳比上一次生成ID時時間戳還小，拋出異常，由於不能保證如今生成的ID以前沒有生成過
                throw new Exception("Clock moved backwards.  Refusing to generate id");
            }

            if (currTimeStamp == lastTimeStamp)
            {
                //相同毫秒內，序列號自增
                sequence = (sequence + 1) & MaxSequence;
                //同一毫秒的序列數已經達到最大
                if (sequence == 0L)
                {
                    currTimeStamp = GetNextMill();
                }
            }
            else
            {
                //不一樣毫秒內，序列號置爲0
                sequence = 0L;
            }

            lastTimeStamp = currTimeStamp;

            return (currTimeStamp - StartTimeStamp) << TimeStampLeft //時間戳部分
                    | dataCenterId << DataCenterLeft       //數據中心部分
                    | machineId << MachingLeft             //機器標識部分
                    | sequence;                             //序列號部分
        }

    }
}

算法測試

測試代碼：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;

namespace SnowflakeDemo
{
    class Program
    {
        static void Main(string[] args)
        {            
            IdWorker idworker = new IdWorker(1, 1);

            Console.WriteLine("開始單線程測試：");
            Stopwatch sw1 = new Stopwatch();
            sw1.Start();
            for (int i = 0; i < 260000; i++)
            {                
                idworker.NextId();                
            }
            sw1.Stop();
            TimeSpan ts = sw1.Elapsed;
            Console.WriteLine("產生26萬個ID須要{0}毫秒",ts.TotalMilliseconds);

            Console.WriteLine();
            Console.WriteLine("開始多線程測試：");
            int threadNum = 10;//測試線程數
            int idNum = 100000;//每一個線程產生的id數
            long[,] idAllAry = new long[threadNum,idNum];
            bool[] completeAry = new bool[threadNum];
            double[] workTimeAry = new double[threadNum];
            Thread[] thAry = new Thread[threadNum];
            for (int i = 0; i < thAry.Length; i++)
            {
                thAry[i] = new Thread(new ParameterizedThreadStart(obj =>
                {
                    int index = (int)obj;
                    Stopwatch sw2 = new Stopwatch();
                    sw2.Start();

                    for (int j = 0; j < idNum; j++)
                    {
                        idAllAry[index,j]=idworker.NextId();
                    }
                    completeAry[index] = true;
                    sw2.Stop();                    
                    workTimeAry[index] = sw2.Elapsed.TotalMilliseconds;

                }));               
            }
            for (int i = 0; i < thAry.Length; i++)
            {
                thAry[i].Start(i);
            }            
            Console.WriteLine(string.Format("運行{0}個線程，每一個線程產生{1}個ID",threadNum,idNum));

            while (completeAry.Where(c => !c).ToList().Count != 0)
            {
                Console.WriteLine("等待執行結果...");
                Thread.Sleep(1000);
            }

            Console.WriteLine(string.Format("單個線程產生ID耗時的最小爲{0}毫秒，最大爲{1}毫秒", workTimeAry.Min(), workTimeAry.Max()));

            List<long> idList = new List<long>();
            for (int i = 0; i < threadNum; i++)
            {
                for (int j = 0; j < idNum; j++)
                {
                    idList.Add(idAllAry[i, j]);
                }
            }
            var qrepeatId = idList.GroupBy(x => x).Where(x => x.Count() > 1).ToList();
            Console.WriteLine(string.Format("ID總數爲{0}，ID重複個數{1}", idList.Count, qrepeatId.Count));

            foreach (var item in qrepeatId)
            {
                Console.WriteLine(item.Key);
            }
            Console.ReadLine();
        }               
    }
}

測試結果：

開始單線程測試：
產生26萬個ID須要972.9153毫秒

開始多線程測試：
運行10個線程，每一個線程產生100000個ID等待執行結果…
待執行結果...
待執行結果...
待執行結果...
待執行結果...
單個線程產生ID耗時的最小爲1895.3256毫秒，最大爲3828.659毫秒
ID總數爲1000000，ID重複個數0

參考文章：
Twitter的分佈式自增ID算法snowflake（雪花算法） - C#版——博客園
 一口氣說出9種分佈式ID生成方式，阿里面試官都懵了——知乎
 雪花算法（SnowFlake）Java實現——簡書
 理解分佈式id生成算法SnowFlake——segmentfault——講解的較爲細緻

簡單實用算法—分佈式自增ID算法snowflake（雪花算法）

算法概述

ID結構

算法特性

算法代碼（C#）

算法測試