关于分布式环境下的id生成

 public class IdWorker
     {
         //基准时间
         public const long Twepoch = 1288834974657L;

         //机器标识位数
         private const int WorkerIdBits = ;

         //数据标志位数
         private const int DatacenterIdBits = ;

         //序列号识位数
         private const int SequenceBits = ;

         //机器ID最大值
         private const long MaxWorkerId = -1L ^ (-1L << WorkerIdBits);

         //数据标志ID最大值
         private const long MaxDatacenterId = -1L ^ (-1L << DatacenterIdBits);

         //序列号ID最大值
         private const long SequenceMask = -1L ^ (-1L << SequenceBits);

         //机器ID偏左移10位
         private const int WorkerIdShift = SequenceBits;

         //数据ID偏左移15位
         private const int DatacenterIdShift = SequenceBits + WorkerIdBits;

         //时间毫秒左移20位
         public const int TimestampLeftShift = SequenceBits + WorkerIdBits + DatacenterIdBits;

         private static readonly DateTime Jan1St1970 = new DateTime
             (, , , , , , DateTimeKind.Utc);

         private readonly object _lock = new object();
         private long _lastTimestamp = -1L;

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

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

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

         public long WorkerId { get; protected set; }
         public long DatacenterId { get; protected set; }

         public long Sequence { get; internal set; }

         public virtual long NextId(long dataNode=)
         {
             lock (_lock)
             {
                 if (dataNode > MaxDatacenterId || dataNode < )
                     throw new ArgumentException($"dataNode 必须大于0，且不能大于MaxWorkerId： {MaxDatacenterId}");
                 if (dataNode == )
                     dataNode = DatacenterId;
                 var timestamp = TimeGen();
                 if (timestamp < _lastTimestamp)
                     throw new Exception($"时间戳必须大于上一次生成ID的时间戳.  拒绝为{_lastTimestamp - timestamp}毫秒生成id");

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

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

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

         /// <summary>
         /// 获取当前的时间戳
         /// </summary>
         /// <returns></returns>
         protected virtual long TimeGen()
         {
             return (long) (DateTime.UtcNow - Jan1St1970).TotalMilliseconds;
         }
     }

 public void GetId()
 {
   new IdWorker(, ).NextId();
 }