Why make a bool volatile when multithreading in C#?

Question

I understand the volatile keyword in C++ fairly well. But in C#, it appears to take a different meaning, more so related to multi-threading. I thought bool operations were atomic, and I thought that if the operation were atomic, you wouldn't have threading concerns. What am I missing?

https://msdn.microsoft.com/en-us/library/x13ttww7.aspx

Answer 1

I thought bool operations were atomic

They are are indeed atomic.

and I thought that if the operation were atomic, you wouldn't have threading concerns.

That is where you have an incomplete picture. Imagine you have two threads running on separate cores, each with their own cache layers. Thread #1 has foo in its cache, and Thread #2 updates the value of foo. Thread #1 won't see the change unless foo is marked as volatile, acquired a lock, used the Interlocked class, or explicitly called Thread.MemoryBarrier() which would cause the value to be invalidated in the cache. Thus, guaranteeing that you read the most up to date value:

Using the volatile modifier ensures that one thread retrieves the most up-to-date value written by another thread.

Eric Lippert has a great post about volatility where he explains:

The true semantics of volatile reads and writes are considerably more complex than I've outlined here; in fact they do not actually guarantee that every processor stops what it is doing and updates caches to/from main memory. Rather, they provide weaker guarantees about how memory accesses before and after reads and writes may be observed to be ordered with respect to each other.

Edit:

As per @xanatos comment, This doesn't mean that volatile guarantees an immediate read, it guarantees a read on the most updated value.