分布式系统唯一ID生成方案汇总

/// <summary>
///根据GUID获取唯一数字序列
/// </summary>
public static longGuidToInt64()
{
    byte[] bytes =Guid.NewGuid().ToByteArray();
    return BitConverter.ToInt64(bytes, 0);
}

/// <summary> 
///Generate a new <see cref="Guid"/>using the comb algorithm. 
/// </summary> 
privateGuid GenerateComb()
{
    byte[] guidArray =Guid.NewGuid().ToByteArray();
    DateTime baseDate = new DateTime(1900, 1, 1);
    DateTime now =DateTime.Now;
    //Get the days and milliseconds which will be used to build    
    //the byte string    
    TimeSpan days = new TimeSpan(now.Ticks -baseDate.Ticks);
    TimeSpan msecs =now.TimeOfDay;
    //Convert to a byte array        
    //Note that SQL Server is accurate to 1/300th of a    
    //millisecond so we divide by 3.333333    
    byte[] daysArray =BitConverter.GetBytes(days.Days);
    byte[] msecsArray = BitConverter.GetBytes((long)
      (msecs.TotalMilliseconds / 3.333333));
    //Reverse the bytes to match SQL Servers ordering    
Array.Reverse(daysArray);
    Array.Reverse(msecsArray);
    //Copy the bytes into the guid    
    Array.Copy(daysArray, daysArray.Length - 2, guidArray,
      guidArray.Length - 6, 2);
    Array.Copy(msecsArray, msecsArray.Length - 4, guidArray,
      guidArray.Length - 4, 4);
    return newGuid(guidArray);
}

/// <summary>
    ///From: https://github.com/twitter/snowflake
    ///An object that generates IDs.
    ///This is broken into a separate class in case
    ///we ever want to support multiple worker threads
    ///per process
    /// </summary>
    public classIdWorker
    {
        private longworkerId;
        private longdatacenterId;
        private long sequence = 0L;
        private static long twepoch = 1288834974657L;
        private static long workerIdBits = 5L;
        private static long datacenterIdBits = 5L;
        private static long maxWorkerId = -1L ^ (-1L << (int)workerIdBits);
        private static long maxDatacenterId = -1L ^ (-1L << (int)datacenterIdBits);
        private static long sequenceBits = 12L;
        private long workerIdShift =sequenceBits;
        private long datacenterIdShift = sequenceBits +workerIdBits;
        private long timestampLeftShift = sequenceBits + workerIdBits +datacenterIdBits;
        private long sequenceMask = -1L ^ (-1L << (int)sequenceBits);
        private long lastTimestamp = -1L;
        private static object syncRoot = new object();
        public IdWorker(long workerId, longdatacenterId)
        {
            //sanity check for workerId
            if (workerId > maxWorkerId || workerId < 0)
            {
                throw new ArgumentException(string.Format("worker Id can't be greater than %d or less than 0", maxWorkerId));
            }
            if (datacenterId > maxDatacenterId || datacenterId < 0)
            {
                throw new ArgumentException(string.Format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
            }
            this.workerId =workerId;
            this.datacenterId =datacenterId;
        }
        public longnextId()
        {
            lock(syncRoot)
            {
                long timestamp =timeGen();
                if (timestamp <lastTimestamp)
                {
                    throw new ApplicationException(string.Format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp -timestamp));
                }
                if (lastTimestamp ==timestamp)
                {
                    sequence = (sequence + 1) &sequenceMask;
                    if (sequence == 0)
                    {
                        timestamp =tilNextMillis(lastTimestamp);
                    }
                }
                else
                {
                    sequence = 0L;
                }
                lastTimestamp =timestamp;
                return ((timestamp - twepoch) << (int)timestampLeftShift) | (datacenterId << (int)datacenterIdShift) | (workerId << (int)workerIdShift) |sequence;
            }
        }
        protected long tilNextMillis(longlastTimestamp)
        {
            long timestamp =timeGen();
            while (timestamp <=lastTimestamp)
            {
                timestamp =timeGen();
            }
            returntimestamp;
        }
        protected longtimeGen()
        {
            return (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
        }
    }

private static voidTestIdWorker()
        {
            HashSet<long> set = new HashSet<long>();
            IdWorker idWorker1 = new IdWorker(0, 0);
            IdWorker idWorker2 = new IdWorker(1, 0);
            Thread t1 = new Thread(() => DoTestIdWoker(idWorker1, set));
            Thread t2 = new Thread(() => DoTestIdWoker(idWorker2, set));
            t1.IsBackground = true;
            t2.IsBackground = true;
            t1.Start();
            t2.Start();
            try
            {
                Thread.Sleep(30000);
                t1.Abort();
                t2.Abort();
            }
            catch(Exception e)
            {
            }
            Console.WriteLine("done");
        }
        private static void DoTestIdWoker(IdWorker idWorker, HashSet<long> set)
        {
            while (true)
            {
                long id =idWorker.nextId();
                if (!set.Add(id))
                {
                    Console.WriteLine("duplicate:" +id);
                }
                Thread.Sleep(1);
            }
        }