I'm trying to understand the C# Volatile class.
As i read:
The Volatile.Write method forces the value in location to be written
to at the point of the call. In addition, any earlier program-order
loads and stores must occur before the call to Volatile.Write.
The Volatile.Read method forces the value in location to be read from
at the point of the call. In addition, any later program-order loads
and stores must occur after the call to Volatile.Read.
Is that means the in the case of:
internal sealed class ThreadsSharingData {
private Int32 m_flag = 0;
private Int32 m_value = 0;
// This method is executed by one thread
public void Thread1() {
// Note: 5 must be written to m_value before 1 is written to m_flag
m_value = 5;
Volatile.Write(ref m_flag, 1);
}
// This method is executed by another thread
public void Thread2() {
// Note: m_value must be read after m_flag is read
if (Volatile.Read(ref m_flag) == 1)
Console.WriteLine(m_value);
}
}
the cpu will wait for the commands before Volatile.Write(ref m_flag, 1); before starting to write to m_flag?
And how is that helps the threads synchronization?
the cpu will wait for the commands before Volatile.Write(ref m_flag, 1); before starting to write to m_flag?
Eeeh, kinda. A better way to phrase this is: it's guaranteed that, if any other thread sees m_flag set to 1, they will also see m_value set to 5.
And how is that helps the threads synchronization?
I wouldn't say it helps with synchronization - but it does help with achieving correctness.
If you weren't using volatile reads/writes, it would be possible for the compiler/runtime/cpu to reorder the two instructions in the Thread1 method, and the program would be able to print either 0, 5 or nothing at all.
With the volatile reads/writes, the program will print either 5 or nothing at all, but never 0. Which is the intended behaviour.
How does that help thread synchronization?
It does not help thread synchronization in the sense of setting the order in which their commands execute. It lets you ensure that a concurrent thread observes changes to values in memory in a specific order, in cases when a particular order is important for the logic of your program.
[Does] the CPU wait for the commands before Volatile.Write(ref m_flag, 1); before starting to write to m_flag?
No, the command to write to m_value has already executed. However, its results may not be visible outside the CPU's core - in particular, a thread running on a different core might read an old value from m_value after the command that wrote 5 to it has finished executing. This is because the new value may be in the cache of the CPU, not in the memory.
If you write
m_value = 5;
m_flag = 1;
instead of Volatile.Write(ref m_flag, 1) the other core may see the writes in a different order: first it would see that m_flag became 1, and after that it would see that m_value became 5. If your other thread uses the value of m_flag to judge the validity of m_value, the logic may be broken: for example, Thread2 may occasionally print zero.
