C# 几种不同thread-safe counter 的作法效能比较

看到专案里面之前用 SemaphoreSlim 来计数，觉得还要dispose 有点麻烦，就google 看看其他人的做法，并写来比较看看效能

这里比较了三种做法的时间，用Unit test 跑的时间来参考，三种分别如下

内建的 Interlocked.Increment、Interlocked.Decrement
1\将++ 与– 用lock 陈述式包起来
2\用 SemaphoreSlim.Release 与 Semaphore.Wait
3\第一种、 Interlocked.Increment、Interlocked.Decrement

        [TestMethod]
        public void InterlockedTest()
        {
            var count = 0;
            var taskList = new List<Task>();
            for (int i = 0; i < 4; i++)
            {
                taskList.Add(Task.Run(() =>
                {
                    for (int j = 0; j < 1_000_000; j++)
                    {
                        Interlocked.Increment(ref count);
                        Interlocked.Decrement(ref count);
                    }
                }));
            }
            Task.WaitAll(taskList.ToArray());
            Assert.AreEqual(0, count);
        }

第二种、将++ 与– 用lock 陈述式包起来

       [TestMethod]
        public void LockTest()
        {
            var myLock = new object();

            var count = 0;
            var taskList = new List<Task>();
            for (int i = 0; i < 4; i++)
            {
                taskList.Add(Task.Run(() =>
                {
                    for (int j = 0; j < 1_000_000; j++)
                    {
                        lock (myLock)
                        {
                            count++;
                        }
                        lock (myLock)
                        {
                            count--;
                        }
                    }
                }));
            }
            Task.WaitAll(taskList.ToArray());
            Assert.AreEqual(0, count);
        }

第三种、用 SemaphoreSlim.Release 与 Semaphore.Wait

        [TestMethod]
        public void SemaphoreSlimTest()
        {
            var count = new SemaphoreSlim(0, int.MaxValue);
            var taskList = new List<Task>();
            for (int i = 0; i < 4; i++)
            {
                taskList.Add(Task.Run(() =>
                {
                    for (int j = 0; j < 1_000_000; j++)
                    {
                        count.Release();
                        count.Wait();
                    }
                }));
            }
            Task.WaitAll(taskList.ToArray());
            Assert.AreEqual(0, count.CurrentCount);
        }

从测试结果看起来，Interlocked 是最快的，但不同的方法有不同的好处，Interlocked 的效能是最高的，如果有需求频繁的加加减减，可以用 Interlocked。Lock 的好处是可以连其他希望Atomic 一起写进去。SemaphoreSlim 则是做其他事情比较好用，因为有支援async Wait，SemaphoreSlim 本身不太适合拿来当Counter，因为只能一定要先加再减，用处比较受限。