为什么 InterLocked 比 lock 慢？

Question

出于好奇，我编写了一个程序来测试 InterLocked 与 .Net 中的锁定的性能。 事实证明，InterLocked 版本比 Locked 版本慢得多，如果我在这里遗漏了一些细节，请有人指出。 根据我的理解，Interlocked 的性能应该比 lock 好得多。

public class TestB
    {
        private static readonly object _objLocker = new object();
        private long _shared;
        public void IncrLocked()
        {
            lock (_objLocker)
            {
                _shared++;
            }
        }
        public void IncrInterLocked()
        {
            Interlocked.Increment(ref _shared);
        }
        public long GetValue()
        {
            return _shared;
        }
    }
    class TestsCopy
    {
        private static TestB _testB = new TestB();
        static void Main(string[] args)
        {
            int numofthreads = 100;
            TestInterLocked(numofthreads);
            TestLocked(numofthreads);
            Console.ReadLine();
        }
        private static void TestInterLocked(int numofthreads)
        {
            Thread[] threads = new Thread[numofthreads];
            for (int i = 0; i < numofthreads; i++)
            {
                Thread t = new Thread(StartTestInterLocked);
                threads[i] = t;
                t.Start();
            }
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < threads.Length; i++)
            {
                threads[i].Join();
            }
            sw.Stop();
            Console.WriteLine($"Interlocked finished in : {sw.ElapsedMilliseconds}, value = {_testB.GetValue()}");
        }

        private static void TestLocked(int numofthreads)
        {
            Thread[] threads = new Thread[numofthreads];
            for (int i = 0; i < numofthreads; i++)
            {
                Thread t = new Thread(StartTestLocked);
                threads[i] = t;
                t.Start();
            }
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < threads.Length; i++)
            {
                threads[i].Join();
            }
            sw.Stop();
            Console.WriteLine($"Locked finished in : {sw.ElapsedMilliseconds}, value = {_testB.GetValue()}");
        }

        private static void StartTestInterLocked()
        {
            int counter = 10000000;
            for (int i = 0; i < counter; i++)
            {
                _testB.IncrInterLocked();
            }
        }
        private static void StartTestLocked()
        {
            int counter = 10000000;
            for (int i = 0; i < counter; i++)
            {
                _testB.IncrLocked();
            }
        }

程序的输出是……

Interlocked finished in : 76909 ms, value = 1000000000
Locked finished in : 44215 ms, value = 2000000000

Answer 1

由于 Jakob Olsen 提到的原因，您的测试存在缺陷。此外，您的测试还包括调用类中方法的开销（对于lock，显然调用Interlocked.Increment() 是无法避免的。

您应该启动所有线程并安排它们在您启动秒表后开始工作。你可以通过让他们等待ManualResetEvent来做到这一点。

我已经像这样重写了你的测试代码：

using System;
using System.Diagnostics;
using System.Threading;

namespace Demo
{
    static class Program
    {
        private static readonly object _objLocker = new object();
        private static long _shared;
        private static ManualResetEvent _signal = new ManualResetEvent(false);

        static void Main(string[] args)
        {
            int numofthreads = 100;
            TestInterLocked(numofthreads);
            TestLocked(numofthreads);
            Console.ReadLine();
        }

        private static void TestInterLocked(int numofthreads)
        {
            Thread[] threads = new Thread[numofthreads];
            for (int i = 0; i < numofthreads; i++)
            {
                Thread t = new Thread(StartTestInterLocked);
                threads[i] = t;
                t.Start();
            }
            Thread.Sleep(5000); // Make sure threads have had time to start.
            Stopwatch sw = new Stopwatch();
            sw.Start();
            _shared = 0;
            _signal.Set();

            for (int i = 0; i < threads.Length; i++)
            {
                threads[i].Join();
            }

            sw.Stop();
            _signal.Reset();
            Console.WriteLine($"Interlocked finished in : {sw.ElapsedMilliseconds}, value = {_shared}");
        }

        private static void TestLocked(int numofthreads)
        {
            Thread[] threads = new Thread[numofthreads];
            for (int i = 0; i < numofthreads; i++)
            {
                Thread t = new Thread(StartTestLocked);
                threads[i] = t;
                t.Start();
            }
            Thread.Sleep(5000); // Make sure threads have had time to start.
            Stopwatch sw = new Stopwatch();
            sw.Start();
            _shared = 0;
            _signal.Set();

            for (int i = 0; i < threads.Length; i++)
            {
                threads[i].Join();
            }

            sw.Stop();
            _signal.Reset();
            Console.WriteLine($"Locked finished in : {sw.ElapsedMilliseconds}, value = {_shared}");
        }

        private static void StartTestInterLocked()
        {
            _signal.WaitOne();
            int counter = 10000000;
            for (int i = 0; i < counter; i++)
            {
                Interlocked.Increment(ref _shared);
            }
        }

        private static void StartTestLocked()
        {
            _signal.WaitOne();
            int counter = 10000000;
            for (int i = 0; i < counter; i++)
            {
                lock (_objLocker)
                {
                    _shared++;
                }
            }
        }
    }
}

现在结果是（来自 RELEASE 版本）：

Interlocked finished in : 11339, value = 1000000000
Locked finished in : 30546, value = 1000000000

如您所见，Interlocked 明显更快。