Understanding C#'s volatile Keyword for Thread Safety

The volatile keyword indicates that a field may be modified by multiple concurrently executing threads. Declaring a field as volatile prevents compiler optimizations that assume single‑threaded access, ensuring the field always reflects the most recent value.

The volatile modifier is typically used for fields accessed by several threads without using lock statements to serialize access (C# reference). For examples of using volatile in multithreaded scenarios, see “Creating and Terminating Threads” in the C# Programming Guide.

volatile can be applied to the following field types:

Reference types.

Pointer types (in unsafe contexts). Note that while the pointer itself can be volatile, the object it points to cannot be volatile; you cannot declare a “pointer to a mutable object” as volatile.

Integral types such as sbyte, byte, short, ushort, int, uint, char, float, and bool.

Enum types with an integral underlying type.

Generic type parameters known to be reference types.

IntPtr and UIntPtr.

Volatile may be applied only to fields of classes or structs; local variables cannot be declared volatile .

Using volatile with a boolean field like _shouldStop allows safe access from multiple threads without formal synchronization because a single atomic operation suffices. However, if the volatile field is a class, struct, or array, concurrent access can cause intermittent data corruption. For example, if one thread modifies an array element while the OS preempts it, another thread may read the array in an inconsistent state, leading to failures.