当前位置：首页 > news >正文

.NET 同步与异步之原子操作和自旋锁（Interlocked、SpinLock）（九）

news 来源：原创 2024/4/25 15:36:39

本随笔续接：.NET 同步与异步之锁（ReaderWriterLockSlim）（八）

之前的随笔已经说过、加锁虽然能很好的解决竞争条件，但也带来了负面影响：性能方面的负面影响。那有没有更好的解决方案呢？有，原子操作、即 Interlocked 这个类。

一、让我们先看一个计数的原子操作Demo

        /// <summary>
        /// 原子操作-计数
        /// </summary>
        public void Demo1()
        {
            Task.Run(() =>
            {
                long total = 0;
                long result = 0;

                PrintInfo("正在计数");

                Parallel.For(0, 10, (i) =>
                {
                    for (int j = 0; j < 10000000; j++)
                    {
                        Interlocked.Increment(ref total);
                        result++;
                    }
                });

                PrintInfo($"操作结果应该为\t\t: {10 * 10000000}");
                PrintInfo($"原子操作结果\t\t: {total}");
                PrintInfo($"i++操作结果\t\t: {result}");
            });
        }

原子操作-计数

由上述Demo可知、Interlocked 可以很好的保证 64位整型值的计数操作能否符合预期，而普通的i++操作却出现了竞争条件。

Interlocked 对于整形操作提供的方法还是很多的，这里不多介绍了。

二、不一样的单例模式

Interlocked 中提供了 Interlocked.CompareExchange<T> 方法的泛型版本，让我们来看一下，这个泛型版本的一种巧妙的用法。

        /// <summary>
        /// 原子操作-单例模式
        /// </summary>
        public void Demo2()
        {
            ConcurrentQueue<InterlockedSingleClass> queue = new ConcurrentQueue<Demo.InterlockedSpinLockClass.InterlockedSingleClass>();

            // 虽然这个测试不严谨、但也或多或少的说明了一些问题
            for (int i = 0; i < 10; i++) // 同时分配的线程数过多、调度器反而调度不过来
            {
                Task.Run(() =>
                {
                    var result = InterlockedSingleClass.SingleInstance;

                    queue.Enqueue(result);
                });
            }


            // 1秒钟后显示结果
            Task.Delay(1000).ContinueWith((t) =>
            {
                PrintInfo($"利用原子操作-单例模式、生成的对象总数:{queue.Count}");

                InterlockedSingleClass firstItem = null;
                queue.TryDequeue(out firstItem);

                for (int i = 0; i < queue.Count;)
                {
                    InterlockedSingleClass temp = null;
                    queue.TryDequeue(out temp);

                    if (temp == null || firstItem == null || !object.ReferenceEquals(temp, firstItem))
                    {
                        PrintInfo("单例模式失效");
                    }
                }

                PrintInfo("原子操作-单例模式-运行完毕");
            });

        }


        public class InterlockedSingleClass
        {
            private static InterlockedSingleClass single = null;

            public static InterlockedSingleClass SingleInstance
            {
                get
                {
                    // if (single == null) // 为了测试效果，该行代码注释掉
                    {
                        Interlocked.CompareExchange<InterlockedSingleClass>(ref single, new InterlockedSingleClass(), null);
                    }

                    return single;
                }
            }

        }

原子操作-单例模式

针对Interlocked.CompareExchange<T>方法、我介绍两句：

1、第一个参数为 ref 参数，如果第一个参数和第三个参数的引用相等，则用第二个参数替换第一个参数的值，并将第一个参数的原始值返回。

2、该泛型方法只接受类类型的参数。

三、自旋锁

自旋锁：提供一个相互排斥锁基元，在该基元中，尝试获取锁的线程将在重复检查的循环中等待，直至该锁变为可用为止。

        /// <summary>
        /// 自旋锁Demo,来源MSDN
        /// </summary>
        public void Demo3()
        {
            SpinLock sl = new SpinLock();

            StringBuilder sb = new StringBuilder();

            // Action taken by each parallel job.
            // Append to the StringBuilder 10000 times, protecting
            // access to sb with a SpinLock.
            Action action = () =>
            {
                bool gotLock = false;
                for (int i = 0; i < 10000; i++)
                {
                    gotLock = false;
                    try
                    {
                        sl.Enter(ref gotLock);

                        sb.Append((i % 10).ToString());
                    }
                    finally
                    {
                        // Only give up the lock if you actually acquired it
                        if (gotLock)
                            sl.Exit();
                    }
                }
            };

            // Invoke 3 concurrent instances of the action above
            Parallel.Invoke(action, action, action);

            // Check/Show the results
            PrintInfo($"sb.Length = {sb.Length} (should be 30000)");

            PrintInfo($"number of occurrences of '5' in sb: {sb.ToString().Where(c => (c == '5')).Count()} (should be 3000)");

        }