问题
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?
回答1:
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.
回答2:
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 tom_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.
来源:https://stackoverflow.com/questions/24307096/understanding-of-volatile-read-write