OLSBackend_Common/JiaZhiQuan.Common/SnowFlake/IdWorker.cs

using System;

namespace JiaZhiQuan.Common.SnowFlake
{
    public class SnowFlakeIdParams
    {
        public DateTime Time { get; set; }
        public int WorkerId { get; set; }
        public int DataCenterId { get; set; }
        public int Sequence { get; set; }
    }


    public class IdWorker
    {

        //基准时间 2019-01-01 00:00:00
        public const long Twepoch = 1546272000000L;
        //机器标识位数
        const int WorkerIdBits = 5;
        //数据标志位数
        const int DatacenterIdBits = 5;
        //序列号识位数
        const int SequenceBits = 12;
        //机器ID最大值
        const long MaxWorkerId = -1L ^ (-1L << WorkerIdBits);
        //数据标志ID最大值
        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;
        private long _lastTimestamp = -1L;

        public long WorkerId { get; protected set; }
        public long DatacenterId { get; protected set; }
        public long Sequence
        {
            get { return _sequence; }
            internal set { _sequence = value; }
        }

        public IdWorker(long workerId, long datacenterId, long sequence = 0L)
        {
            // 如果超出范围就抛出异常
            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("datacenter Id 必须大于0，且不能大于MaxDatacenterId： {0}", MaxDatacenterId));
            }

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

        /// <summary>
        /// 获取给定时间开始最小的Id值
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns></returns>
        public static long GetStartIdByDate(DateTime dateTime)
        {
            dateTime = dateTime.ToUniversalTime();
            long timestamp = (long)(dateTime - TimeExtensions.Jan1st1970).TotalMilliseconds;
            return (timestamp - Twepoch) << TimestampLeftShift;
        }

        public static SnowFlakeIdParams DecodeId(long id)
        {
            return new SnowFlakeIdParams()
            {
                Time = new DateTime(((id >> TimestampLeftShift) + Twepoch) * 10000 + TimeExtensions.Jan1st1970.Ticks, DateTimeKind.Utc).ToLocalTime(),
                DataCenterId = (int)(id >> DatacenterIdShift) & 0x1F,
                WorkerId = (int)(id >> WorkerIdShift) & 0x1F,
                Sequence = (int)(id & 0xFFF)
            };
        }

        readonly object _lock = new Object();
        public virtual long NextId()
        {
            lock (_lock)
            {
                var timestamp = TimeGen();
                if (timestamp < _lastTimestamp)
                {
                    throw new Exception(string.Format("时间戳必须大于上一次生成ID的时间戳.  拒绝为{0}毫秒生成id", _lastTimestamp - timestamp));
                }

                //如果上次生成时间和当前时间相同,在同一毫秒内
                if (_lastTimestamp == timestamp)
                {
                    //sequence自增，和sequenceMask相与一下，去掉高位
                    _sequence = (_sequence + 1) & SequenceMask;
                    //判断是否溢出,也就是每毫秒内超过1024，当为1024时，与sequenceMask相与，sequence就等于0
                    if (_sequence == 0)
                    {
                        //等待到下一毫秒
                        timestamp = TilNextMillis(_lastTimestamp);
                    }
                }
                else
                {
                    //如果和上次生成时间不同,重置sequence，就是下一毫秒开始，sequence计数重新从0开始累加,
                    //为了保证尾数随机性更大一些,最后一位可以设置一个随机数
                    _sequence = 0;//new Random().Next(10);
                }

                _lastTimestamp = timestamp;
                return ((timestamp - Twepoch) << TimestampLeftShift) | (DatacenterId << DatacenterIdShift) | (WorkerId << WorkerIdShift) | _sequence;
            }
        }

        /// <summary>
        /// 根据时间来创建编号，Sequence随机
        /// </summary>
        public virtual long NextId(DateTime dateTime)
        {
            dateTime = dateTime.ToUniversalTime();
            long timestamp = (long)(dateTime - TimeExtensions.Jan1st1970).TotalMilliseconds;
            return ((timestamp - Twepoch) << TimestampLeftShift) | (DatacenterId << DatacenterIdShift) | (WorkerId << WorkerIdShift) | (long)(new Random().Next((int)SequenceMask));
        }


        // 防止产生的时间比之前的时间还要小（由于NTP回拨等问题）,保持增量的趋势.
        protected virtual long TilNextMillis(long lastTimestamp)
        {
            var timestamp = TimeGen();
            while (timestamp <= lastTimestamp)
            {
                timestamp = TimeGen();
            }
            return timestamp;
        }

        // 获取当前的时间戳
        protected virtual long TimeGen()
        {
            return TimeExtensions.CurrentTimeMillis();
        }
    }
}