C# lock和Interlocked性能测试

最新推荐文章于 2025-06-13 15:02:13 发布

IIN22

最新推荐文章于 2025-06-13 15:02:13 发布

阅读量4.4k

点赞数

CC 4.0 BY-SA版权

分类专栏： C# 锁

本文链接：https://blog.youkuaiyun.com/IIN22/article/details/89887923

C# 同时被 2 个专栏收录

4 篇文章

订阅专栏

锁

1 篇文章

订阅专栏

博客围绕代码测试展开，在4核CPU、16G内存、win7的测试机器上，设置不同线程数，每个线程计算10000000次并跑10遍进行测试。当线程数为4和10时，CPU占用达100%，此时压力测试意义不大，在CPU可用范围内，Interlocked性能更优越。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

测试代码

public class LockTest
    {
        private static object lockObj = new object();

        private static int Count = 0;

        public static void Test()
        {
            int threadCount = 10;
            for (int k = 0; k < 10; k++)
            {
                Count = 0;
                var watch = new Stopwatch();
                watch.Start();
                var tasks = new List<Task>();
                for (int i = 0; i < threadCount; i++)
                {
                    var task = Task.Factory.StartNew(
                        () =>
                        {
                            for (int j = 0; j < 10000000; j++)
                            {
                                OnlyLockTest();
                            }
                        });
                    tasks.Add(task);
                }

                Task.WaitAll(tasks.ToArray());
                watch.Stop();
                Console.WriteLine(k + 1 + " 线程数：" + threadCount + "， Lock耗时:" + watch.ElapsedTicks + "，计算结果： " + Count);

                Count = 0;
                watch = new Stopwatch();
                watch.Start();
                var tasks1 = new List<Task>();
                for (int i = 0; i < threadCount; i++)
                {
                    var task = Task.Factory.StartNew(
                        () =>
                        {
                            for (int j = 0; j < 10000000; j++)
                            {
                                InterlockedTest();
                            }
                        });
                    tasks1.Add(task);
                }

                Task.WaitAll(tasks1.ToArray());
                watch.Stop();
                Console.WriteLine(k + 1 + " 线程数：" + threadCount + "， Interlocked耗时:" + watch.ElapsedTicks + "，计算结果： " + Count);
            }

        }

        private static void OnlyLockTest()
        {
            lock (lockObj)
            {
                Count++;
            }
        }

        private static void InterlockedTest()
        {
            Interlocked.Increment(ref Count);
        }
    }

测试结果

测试机器：4核cpu，16G内存，win7

设置线程数为2，执行10000000次，跑10遍