Free-ebooks-library - Bahar Ali Khan

If methods A and B ran concurrently on different threads, might it be possible for B
to write “0”? The answer is yes—for the following reasons:
• The compiler, CLR, or CPU may reorder your program’s instructions to improve
efficiency.
• The compiler, CLR, or CPU may introduce caching optimizations such that
assignments to variables won’t be visible to other threads right away.
C# and the runtime are very careful to ensure that such optimizations don’t break
ordinary single-threaded code—or multithreaded code that makes proper use of
locks. Outside of these scenarios, you must explicitly defeat these optimizations by
creating memory barriers (also called memory fences) to limit the effects of instruction
reordering and read/write caching.
Full fences
The simplest kind of memory barrier is a full memory barrier (full fence), which
prevents any kind of instruction reordering or caching around that fence. Calling
Thread.MemoryBarrier generates a full fence; we can fix our example by applying four
full fences as follows:
class Foo
{
int _answer;
bool _complete;
void A()
{
_answer = 123;
Thread.MemoryBarrier(); // Barrier 1
_complete = true;
Thread.MemoryBarrier(); // Barrier 2
}
void B()
{
Thread.MemoryBarrier(); // Barrier 3
if (_complete)
{
Thread.MemoryBarrier(); // Barrier 4
Console.WriteLine (_answer);
}
}
}
Barriers 1 and 4 prevent this example from writing “0”. Barriers 2 and 3 provide a
freshness guarantee: they ensure that if B ran after A, reading _complete would evaluate
to true.
A full fence takes a few tens of nanoseconds.
826 | Chapter 21: Threading