测试IIS多进程下，c#版雪花算法的值大量重复

线上找的雪花算法及说明：https://www.cnblogs.com/yushuo/p/9406906.html

较真的态度，验证如下：

1.修正代码，示例代码有调用错误：nuget安装sqlsugar，framework4.6.1版本

  //核心算法

namespace webapi2   
{
    //核心算法
    public class SnowflakeNet
    {
        //基准时间
        private static long StartStmp = 1288834974657L;
        //private const long START_STMP = 1480166465631L;
        /*每一部分占用的位数*/
        //机器标识位数
        const int MachineIdBits = 5;
        //数据标志位数
        const int DatacenterIdBits = 5;
        //序列号识位数
        const int SequenceBits = 12;

        /* 每一部分的最大值*/
        //机器ID最大值
        const long MaxMachineNum = -1L ^ (-1L << MachineIdBits);
        //数据标志ID最大值
        const long MaxDatacenterNum = -1L ^ (-1L << DatacenterIdBits);
        //序列号ID最大值
        private const long MaxSequenceNum = -1L ^ (-1L << SequenceBits);

        /*每一部分向左的位移*/
        //机器ID偏左移12位
        private const int MachineShift = SequenceBits;
        //数据ID偏左移17位
        private const int DatacenterIdShift = SequenceBits + MachineIdBits;
        //时间毫秒左移22位
        public const int TimestampLeftShift = SequenceBits + MachineIdBits + DatacenterIdBits;


        private long _sequence = 0L;//序列号
        private long _lastTimestamp = -1L;//上一次时间戳
        public long MachineId { get; protected set; }//机器标识
        public long DatacenterId { get; protected set; }//数据中心
        //public long Sequence = 0L;//序列号
        //{
        //    get { return _sequence; }
        //    internal set { _sequence = value; }
        //}

        private readonly DateTime Jan1st1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        private readonly object _lock = new Object();
        public SnowflakeNet(long machineId, long datacenterId)
        {
            // 如果超出范围就抛出异常
            if (machineId > MaxMachineNum || machineId < 0)
            {
                throw new ArgumentException(string.Format("machineId 必须大于0，MaxMachineNum： {0}", MaxMachineNum));
            }

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

            //先检验再赋值
            MachineId = machineId;
            DatacenterId = datacenterId;
            //_sequence = sequence;
        }

        //public static Init(long machineId, long datacenterId)
        //{

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

                _lastTimestamp = timestamp;
                return ((timestamp - StartStmp) << TimestampLeftShift) | (DatacenterId << DatacenterIdShift) | (MachineId << MachineShift) | _sequence;
            }
        }

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

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

//封装调用

namespace webapi2
{
    public class IdWorkerHelper
    {
        private static SnowflakeNet _idWorker= null;
        private IdWorkerHelper()
        {

        }

        static IdWorkerHelper()
        {
            _idWorker = new SnowflakeNet(1, 1);
        }
        public static long GenId64()
        {
            return _idWorker.NextId();

        }
    }
}

//数据入库

namespace webapi2
{
    public class IDLog
    {
        public long ID { get; set; }
        public DateTime Dt { get; set; }
    }
}

namespace webapi2
{
    public class IDLogTester:DbContext<IDLog>
    {
        //sqlsugar入库
        public string IdTest()
        {
            IDLog model = new IDLog();
            model.ID = IdWorkerHelper.GenId64();
            model.Dt = DateTime.Now;
            Db.Insertable(model).ExecuteCommand();
            return JsonConvert.SerializeObject(model);
        }
    }
}

//webapi调用

namespace webapi2.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            ViewBag.Title = "Home Page";

            return View();
        }

        [Route("IdTest")]
        [HttpGet]
        public ActionResult IdTest()
        {
            var test = new IDLogTester();
            var result = test.IdTest();
            return Content(result);
        }
    }
}

2.部署iis：设置最大进程数==2

3.压测工具：TCPBenchmarks压测工具,https://github.com/beetlex-io/TCPBenchmarks

自行下载使用

4.压测结果：果然大量重复，26万数据，产生9成多行重复

 

---

5.如果只用一个IIS进程，不会出现此问题,已验证，50并发下一分钟产生40万条数据，一条也没重复。

6.原因：

iis多进程下，相当于部署到多台机器，但每台机器配置的机器码一致，所以产生的碰撞机率很高。

7.解决：

思路一：保持现有代码不同，部署到iis上设置只能单进程使用。

思路二：使用nginx反向代理使用，后面部署多台iis机器，但每台机器只能单进程并设置不同的机器码，也就是此行代码的构造参数不同。这才是分布式id的常用方法吧。

  static IdWorkerHelper()
        {
            //部署多台机器时，参数需要不同
            _idWorker = new SnowflakeNet(1, 1);
        }

 思路三：使用互斥锁中的进程锁Mutex，代码修改

//生成id的核心方法，把互斥锁-线程锁lock替换为Mutex
 public static Mutex mutex = new Mutex();
        public long NextId()
        {
            //lock (this)
            //{
            mutex.WaitOne();
            long timestamp = GetCurrentTimestamp();
            if (timestamp > lastTimestamp) //时间戳改变，毫秒内序列重置
            {
                sequence = 0L;
            }
            else if (timestamp == lastTimestamp) //如果是同一时间生成的，则进行毫秒内序列
            {
                sequence = (sequence + 1) & sequenceMask;
                if (sequence == 0) //毫秒内序列溢出
                {
                    timestamp = GetNextTimestamp(lastTimestamp); //阻塞到下一个毫秒,获得新的时间戳
                }
            }
            else   //当前时间小于上一次ID生成的时间戳，证明系统时钟被回拨，此时需要做回拨处理
            {
                sequence = (sequence + 1) & sequenceMask;
                if (sequence > 0)
                {
                    timestamp = lastTimestamp;     //停留在最后一次时间戳上，等待系统时间追上后即完全度过了时钟回拨问题。
                }
                else   //毫秒内序列溢出
                {
                    timestamp = lastTimestamp + 1;   //直接进位到下一个毫秒
                }
                //throw new Exception(string.Format("Clock moved backwards.  Refusing to generate id for {0} milliseconds", lastTimestamp - timestamp));
            }

            lastTimestamp = timestamp;       //上次生成ID的时间截

            //移位并通过或运算拼到一起组成64位的ID
            var id = ((timestamp - twepoch) << timestampLeftShift)
                    | (datacenterId << datacenterIdShift)
                    | (workerId << workerIdShift)
                    | sequence;
            mutex.ReleaseMutex();
            return id;
            //}
        }

性能：配置2进程，使用进程锁(mutex)，一分钟压测：

性能：配置1进程，使用线程锁（lock），一分钟压测：

可以看出性能相差并不多

思路四：换成netcore版本的snowflake待测试！！！！！