c# - 具有 volatile 或锁定的属性

Question

我有一个带有支持字段的属性，我想使其线程安全(获取和设置)。get和set方法除了设置和返回之外没有任何逻辑。

我认为有两种方法可以将逻辑封装在属性 self 中( volatile 和锁定)。我对两者的理解是正确的还是有错误？

以下是我的示例:

    public class ThreadSafeClass
    {
        // 1. Volatile Example:

        private volatile int _processState_1;
        public int ProcessState_1
        {
            get { return _processState_1; }
            set { _processState_1 = value; }
        }

        // 2. Locking Example:

        private readonly object _processState_2Lock = new object();
        private int _processState_2;
        public int ProcessState_2
        {
            get
            {
                lock (_processState_2Lock)
                {
                    return _processState_2;
                }
            }
            set
            {
                lock (_processState_2Lock)
                {
                    _processState_2 = value;
                }
            }
        }
    }

Answer 1

有关更多信息，请参阅great site by J. Albahari :

同步结构可以分为四类:

简单的拦截方法:

这些等待另一个线程完成或经过一段时间。 Sleep、Join 和 Task.Wait 是简单的阻塞方法。

锁定结构:

这些限制了一次可以执行某些事件或执行一段代码的线程数量。独占锁定结构是最常见的——它们一次只允许一个线程进入，并允许竞争线程访问公共(public)数据而不会互相干扰。标准独占锁定构造是 lock (Monitor.Enter/Monitor.Exit)、Mutex 和 自旋锁。非独占锁定结构是Semaphore、SemaphoreSlim和读取器/写入器锁。

信号构建:

这些允许线程暂停，直到收到另一个线程的通知，从而避免低效的轮询。有两种常用的信号设备:事件等待句柄和监视器的等待/脉冲方法。 Framework 4.0 引入了 CountdownEvent 和 Barrier 类。

非阻塞同步结构:

它们通过调用处理器原语来保护对公共(public)字段的访问。 CLR 和 C# 提供以下非阻塞构造:Thread.MemoryBarrier、Thread.VolatileRead、Thread.VolatileWrite、 volatile code> 关键字和 Interlocked 类。

<小时/>

volatile 关键字:

volatile 关键字指示编译器在每次读取该字段时生成一个获取栅栏，并在每次写入该字段时生成一个释放栅栏。获取栅栏可防止其他读/写在栅栏之前移动；释放栅栏可防止其他读/写在栅栏之后移动。这些“半栅栏”比全栅栏更快，因为它们为运行时和硬件提供了更多优化空间。

As it happens, Intel’s X86 and X64 processors always apply acquire-fences to reads and release-fences to writes — whether or not you use the volatile keyword — so this keyword has no effect on the hardware if you’re using these processors. However, volatile does have an effect on optimizations performed by the compiler and the CLR — as well as on 64-bit AMD and (to a greater extent) Itanium processors. This means that you cannot be more relaxed by virtue of your clients running a particular type of CPU.

将 volatile 应用于字段的效果可以总结如下:

First instruction   Second instruction  Can they be swapped?
Read                Read                No
Read                Write               No
Write               Write               No (The CLR ensures that write-write operations are never swapped, even without the volatile keyword)
Write               Read                Yes!

请注意，应用 volatile 并不会阻止先写后读的交换，这可能会造成脑筋急转弯。 Joe Duffy 通过以下示例很好地说明了该问题:如果 Test1 和 Test2 在不同线程上同时运行，则 a 和 b 的最终值可能均为 0 (尽管在 x 和 y 上都使用了 volatile):

class IfYouThinkYouUnderstandVolatile
{
  volatile int x, y;

  void Test1()        // Executed on one thread
  {
    x = 1;            // Volatile write (release-fence)
    int a = y;        // Volatile read (acquire-fence)
    ...
  }

  void Test2()        // Executed on another thread
  {
    y = 1;            // Volatile write (release-fence)
    int b = x;        // Volatile read (acquire-fence)
    ...
  }
}

The MSDN documentation states that use of the volatile keyword ensures that the most up-to-date value is present in the field at all times. This is incorrect, since as we’ve seen, a write followed by a read can be reordered.

这为避免 volatile 提供了强有力的理由:即使您理解此示例中的微妙之处，其他处理您代码的开发人员也会理解它吗？ Test1 和 Test2 中的两个分配之间的完整栅栏(或锁)解决了该问题。

传引用参数或捕获的局部变量不支持 volatile 关键字:在这些情况下，您必须使用 VolatileRead 和 VolatileWrite 方法。