在C＃中使用Volatile.Write（）而不是volatile

Question

Assume the following code (note that this is only an example code):

public async void UnsafeMethod()
{
  int unsafeValue = 0;

  Task.Run(() => unsafeValue = 42 ); // set unsafeValue to some value
  await Task.Delay(10);              // wait for some time

  Assert.AreEqual(42, unsafeValue);  // check if unsafeValue has the new value
}

(Assume here that the CPU is idle and executes the task immediately.)

Since the task will be executed on a new thread, the new value of unsaveValue might not be visible to other threads due to possible caching issues. If i want to make the change visible, i would have to use volatile and make the local variable a field:

private volatile int safeValue = 0;

public async void SafeMethod()
{
  Task.Run(() => safeValue = 42 ); // set safeValue to some value
  await Task.Delay(10);            // wait for some time

  Assert.AreEqual(42, safeValue);  // check if safeValue has the new value
}

(Assume again that the task is executed immediately.)

My question now is, if the following will do the same while keeping the local variable (i know, the compiler makes it a field anyways...):

public async void AnotherMethod()
{
  int safeValue = 0;

  Task.Run(() => Volatile.Write(ref safeValue, 42); // set safeValue to some value
  await Task.Delay(10);                             // wait for some time

  Assert.AreEqual(42, safeValue);                   // check if safeValue has the new value
}

(Task gets executed immediately.)

The documentation is not entirely clear to me. https://msdn.microsoft.com/en-us/library/system.threading.volatile(v=vs.110).aspx

It states:

On a multiprocessor system, a volatile write operation ensures that a value written to a memory location is immediately visible to all processors.

which is what I want. However, it also states:

Writes the specified value to the specified field. On systems that require it, inserts a memory barrier that prevents the processor from reordering memory operations as follows: If a read or write appears before this method in the code, the processor cannot move it after this method.

at the method description, which I am not sure if this is what I want.

Again my question: Will the last code snipped do what i want it to do (make the write immediately visible to other threads)?

Answer 1

As Matteo Umili and Matthew Watson mentioned in the comments you have to use Volatile.Read when you read a non-volatile field. That's because synchronization is always a 2 player game.

In this case Volatile.Write inserts store-release barrier after the write and Volatile.Read sets load-acquire barrier before the read.