雪花算法的原理和实现

雪花算法SnowFlake 算法，是 Twitter 开源的分布式 id 生成算法。其核心思想就是：使用一个 64 bit 的 long 型的数字作为全局唯一 id。在分布式系统中的应用十分广泛，且ID 引入了时间戳，基本上保持自增的，后面的代码中有详细的注解。 

这 64 个 bit 中，其中 1 个 bit 是不用的，然后用其中的 41 bit 作为毫秒数，用 10 bit 作为工作机器 id，12 bit 作为序列号。 

给大家举个例子吧，比如下面那个 64 bit 的 long 型数字：

第一个部分，是 1 个 bit：0，这个是无意义的。

第二个部分是 41 个 bit：表示的是时间戳。

第三个部分是 5 个 bit：表示的是机房 id，10001。

第四个部分是 5 个 bit：表示的是机器 id，1 1001。

第五个部分是 12 个 bit：表示的序号，就是某个机房某台机器上这一毫秒内同时生成的 id 的序号，0000 00000000。 

①1 bit：是不用的，为啥呢？ 

因为二进制里第一个 bit 为如果是 1，那么都是负数，但是我们生成的 id 都是正数，所以第一个 bit 统一都是 0。 

②41 bit：表示的是时间戳，单位是毫秒。 

41 bit 可以表示的数字多达 2^41 - 1，也就是可以标识 2 ^ 41 - 1 个毫秒值，换算成年就是表示 69 年的时间。 

③10 bit：记录工作机器 id，代表的是这个服务最多可以部署在 2^10 台机器上，也就是 1024 台机器。 

但是 10 bit 里 5 个 bit 代表机房 id，5 个 bit 代表机器 id。意思就是最多代表 2 ^ 5 个机房（32 个机房），每个机房里可以代表 2 ^ 5 个机器（32 台机器），也可以根据自己公司的实际情况确定。 

④12 bit：这个是用来记录同一个毫秒内产生的不同 id。 

12 bit 可以代表的最大正整数是 2 ^ 12 - 1 = 4096，也就是说可以用这个 12 bit 代表的数字来区分同一个毫秒内的 4096 个不同的 id。 

简单来说，你的某个服务假设要生成一个全局唯一 id，那么就可以发送一个请求给部署了 SnowFlake 算法的系统，由这个 SnowFlake 算法系统来生成唯一 id。 

这个 SnowFlake 算法系统首先肯定是知道自己所在的机房和机器的，比如机房 id = 17，机器 id = 12。 

接着 SnowFlake 算法系统接收到这个请求之后，首先就会用二进制位运算的方式生成一个 64 bit 的 long 型 id，64 个 bit 中的第一个 bit 是无意义的。 

接着 41 个 bit，就可以用当前时间戳（单位到毫秒），然后接着 5 个 bit 设置上这个机房 id，还有 5 个 bit 设置上机器 id。 

最后再判断一下，当前这台机房的这台机器上这一毫秒内，这是第几个请求，给这次生成 id 的请求累加一个序号，作为最后的 12 个 bit。 

最终一个 64 个 bit 的 id 就出来了，类似于： 

这个算法可以保证说，一个机房的一台机器上，在同一毫秒内，生成了一个唯一的 id。可能一个毫秒内会生成多个 id，但是有最后 12 个 bit 的序号来区分开来。 

下面我们简单看看这个 SnowFlake 算法的一个代码实现，这就是个示例，大家如果理解了这个意思之后，以后可以自己尝试改造这个算法。 

总之就是用一个 64 bit 的数字中各个 bit 位来设置不同的标志位，区分每一个 id。

SnowFlake 算法的实现代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Utils
{
    public class IdWorker
    {
        //基准时间,设置一个时间初始值,2^41 - 1差不多可以用69年
        //时间戳是指格林威治时间自1970年1月1日（00:00:00 GTM）至当前时间的总秒数。它也被称为Unix时间戳（Unix Timestamp）
        //时间戳是能够表示一份数据在一个特定时间点已经存在的完整的可验证的数据，通常是一个字符序列，唯一地标识某一刻的时间
        public const long Twepoch = 1288834974657L;//北京时间 2010-11-04 09:42:54=1288834974657毫秒，时间戳
        //机器标识位数,5位的机器id
        const int WorkerIdBits = 5;
        //数据标志位数,5位的机房id
        const int DatacenterIdBits = 5;
        //序列号识位数,每毫秒内产生的id数 2 的 12次方
        const int SequenceBits = 12;
        //机器ID最大值,这个是二进制运算，就是5 bit最多只能有31个数字，也就是说机器id最多只能是32以内
        const long MaxWorkerId = -1L ^ (-1L << WorkerIdBits);
        //数据标志ID最大值,这个是一个意思，就是5 bit最多只能有31个数字，机房id最多只能是32以内
        const long MaxDatacenterId = -1L ^ (-1L << DatacenterIdBits);
        //序列号ID最大值
        private const long SequenceMask = -1L ^ (-1L << SequenceBits);
        //机器ID偏左移12位
        private const int WorkerIdShift = SequenceBits;
        //数据ID偏左移17位
        private const int DatacenterIdShift = SequenceBits + WorkerIdBits;
        //时间毫秒左移22位
        public const int TimestampLeftShift = SequenceBits + WorkerIdBits + DatacenterIdBits;

        private long _sequence = 0L;
        //记录产生时间毫秒数，判断是否是同1毫秒
        private long _lastTimestamp = -1L;

        //因为二进制里第一个 bit 为如果是 1，那么都是负数，但是我们生成的 id 都是正数，所以第一个 bit 统一都是 0。

        //机器ID  2进制5位  32位减掉1位 31个
        public long WorkerId { get; protected set; }
        //机房ID 2进制5位  32位减掉1位 31个
        public long DatacenterId { get; protected set; }
        //代表一毫秒内生成的多个id的最新序号  12位 4096 -1 = 4095 个
        public long Sequence
        {
            get { return _sequence; }
            internal set { _sequence = value; }
        }

        public IdWorker(long workerId, long datacenterId, long sequence = 0L)
        {
            // 如果超出范围就抛出异常,检查机房id和机器id是否超过31 不能小于0
            if (workerId > MaxWorkerId || workerId < 0)
            {
                throw new ArgumentException(string.Format("worker Id 必须大于0，且不能大于MaxWorkerId： {0}", MaxWorkerId));
            }

            if (datacenterId > MaxDatacenterId || datacenterId < 0)
            {
                throw new ArgumentException(string.Format("region Id 必须大于0，且不能大于MaxWorkerId： {0}", MaxDatacenterId));
            }

            //先检验再赋值
            WorkerId = workerId;
            DatacenterId = datacenterId;
            _sequence = sequence;
        }

        readonly object _lock = new object();

        /// 

        /// 核心方法，通过调用nextId()方法，让当前这台机器上的snowflake算法程序生成一个全局唯一的id
        /// 
        /// 
        /// 
        public virtual long NextId()
        {
            lock (_lock)
            {
                //获取当前时间戳，单位是毫秒
                var timestamp = TimeGen();
                if (timestamp < _lastTimestamp)
                {
                    throw new Exception(string.Format("时间戳必须大于上一次生成ID的时间戳.  拒绝为{0}毫秒生成id", _lastTimestamp - timestamp));
                }

                //如果上次生成时间和当前时间相同,在同一毫秒内,下面是说假设在同一个毫秒内，又发送了一个请求生成一个id,这个时候就得把seqence序号给递增1，最多就是4096
                if (_lastTimestamp == timestamp)
                {
                    //sequence自增，和sequenceMask相与一下，去掉高位,
                    //这个意思是说一个毫秒内最多只能有4096个数字，无论你传递多少进来，
                    //这个位运算保证始终就是在4096这个范围内，避免你自己传递个sequence超过了4096这个范围
                    _sequence = (_sequence + 1) & SequenceMask;
                    //判断是否溢出,也就是每毫秒内超过1024，当为1024时，与sequenceMask相与，sequence就等于0
                    //当某一毫秒的时间，产生的id数 超过4095，系统会进入等待，直到下一毫秒，系统继续产生ID
                    if (_sequence == 0)
                    {
                        //等待到下一毫秒
                        timestamp = TilNextMillis(_lastTimestamp);
                    }
                }
                else
                {
                    //如果和上次生成时间不同,重置sequence，就是下一毫秒开始，sequence计数重新从0开始累加,
                    //为了保证尾数随机性更大一些,最后一位可以设置一个随机数
                    _sequence = 0;//new Random().Next(10);
                }
                // 这儿记录一下最近一次生成id的时间戳，单位是毫秒
                _lastTimestamp = timestamp;
                // 这儿就是最核心的二进制位运算操作，生成一个64bit的id
                // 先将当前时间戳左移，放到41 bit那儿；将机房id左移放到5 bit那儿；将机器id左移放到5 bit那儿；将序号放最后12 bit
                // 最后拼接起来成一个64 bit的二进制数字，转换成10进制就是个long型
                return ((timestamp - Twepoch) << TimestampLeftShift) | (DatacenterId << DatacenterIdShift) | (WorkerId << WorkerIdShift) | _sequence;
            }
        }

        /// 

        /// 防止产生的时间比之前的时间还要小（由于NTP回拨等问题）,保持增量的趋势.
        /// 当某一毫秒的时间，产生的id数 超过4095，系统会进入等待，直到下一毫秒，系统继续产生ID
        /// 
        /// 
        /// 
        protected virtual long TilNextMillis(long lastTimestamp)
        {
            var timestamp = TimeGen();
            while (timestamp <= lastTimestamp)
            {
                timestamp = TimeGen();
            }
            return timestamp;
        }

        /// 

        /// 获取当前时间戳
        /// 
        /// 
        protected virtual long TimeGen()
        {
            //TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            //return Convert.ToInt64(ts.TotalSeconds);
            //return DateTime.Now.Millisecond;//当前时间的毫秒数
            return TimeExtensions.CurrentTimeMillis();
        }
    }

    public static class TimeExtensions
    {
        private static Func _currentTimeFunc = InternalCurrentTimeMillis;

        public static long CurrentTimeMillis()
        {
            return _currentTimeFunc();
        }

        public static IDisposable StubCurrentTime(Func func)
        {
            _currentTimeFunc = func;
            return new DisposableAction(() =>
            {
                _currentTimeFunc = InternalCurrentTimeMillis;
            });
        }

        public static IDisposable StubCurrentTime(long millis)
        {
            _currentTimeFunc = () => millis;
            return new DisposableAction(() =>
            {
                _currentTimeFunc = InternalCurrentTimeMillis;
            });
        }

        private static readonly DateTime Jan1st1970 = new DateTime
           (1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

        private static long InternalCurrentTimeMillis()
        {
            return (long)(DateTime.UtcNow - Jan1st1970).TotalMilliseconds;
        }
    }

    public class DisposableAction : IDisposable
    {
        readonly Action _action;

        public DisposableAction(Action action)
        {
            _action = action ?? throw new ArgumentNullException(nameof(action));
        }

        public void Dispose()
        {
            _action();
        }
    }

    public static class Long2ShortIdExtension
    {
        public static string GetShortIdString(this long id)
        {
            string idStr = id.ToString();
            char[] num = idStr.ToCharArray();
            double sum = 0;
            for (int i = 0; i < num.Length; i++)
            {
                var coefficient = Math.Pow(6, i + 3) % 11;//计算加权系数,加权系数计算方式参考ISO 7064:1983.MOD11-2校验码计算法
                int x = int.Parse(num[i].ToString());
                sum += coefficient * x;
            }
            string verCode = (sum % 11).ToString("00");
            string preFix = idStr.Substring(idStr.Length - 4);
            return $"{preFix}{verCode}";
        }
        public static int GetShortId(this long id)
        {
            return int.Parse(id.GetShortIdString());
        }

        public static string GetIdSuffix(this long id, int length = 6)
        {
            string idStr = id.ToString();
            if (length > idStr.Length)
                length = idStr.Length;
            string suffix = idStr.Substring(idStr.Length - length);
            return suffix;
        }
    }

    /// 

    /// 测试雪花id
    /// 
    public static class TestSnowflake
    {
        public static IdWorker idWorker { get; set; }
        static TestSnowflake()
        {
            //var workIdStr = APPConfigurationManager.Instance.GetAppSettings("WorkerId");
            //var datacenterIdStr = APPConfigurationManager.Instance.GetAppSettings("DataCenterId");
            //if (string.IsNullOrWhiteSpace(workIdStr) || string.IsNullOrWhiteSpace(datacenterIdStr))
            //{
            //    workIdStr = "1";
            //    datacenterIdStr = "1";
            //}
            idWorker = new IdWorker(1, 1);
        }
        public static long TestNextID()
        {
            long id = idWorker.NextId();
            string shortId = id.GetShortIdString();
            Console.WriteLine($"{id}, {shortId}");
            return id;
        }
    }
}

测试

static class Program
    {
        /// 

        /// 应用程序的主入口点。
        /// 
        [STAThread]
        static void Main()
        {
                var workIdStr = APPConfigurationManager.Instance.GetAppSettings("WorkerId");
                var datacenterIdStr = APPConfigurationManager.Instance.GetAppSettings("DataCenterId");
                //负载均衡部署的时候，一定要给定环境变量！或者在appsettings.json中给定不同的WorkerId、DataCenterId
                if (string.IsNullOrWhiteSpace(workIdStr) || string.IsNullOrWhiteSpace(datacenterIdStr))
                {
                    workIdStr = "1";
                    datacenterIdStr = "1";
                }
                IdWorker idWorker = null;
                if (long.TryParse(workIdStr, out long workId) && long.TryParse(datacenterIdStr, out long datacenterId))
                {
                    idWorker = new IdWorker(workId, datacenterId);
                    //IdWorker idWorker = new IdWorker(1, 1);
                }
                long id = idWorker.NextId();
                string shortId = id.GetShortIdString();
                Console.WriteLine($"{id}, {shortId}");
      }
   }

参考链接：雪花算法的原理和实现Java_雨夜青草的博客-CSDN博客_雪花算法