# volatile

Domains:

The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. The compiler, the runtime system, and even hardware may rearrange reads and writes to memory locations for performance reasons. Fields that are declared volatile are not subject to these optimizations. Adding the volatile modifier ensures that all threads will observe volatile writes performed by any other thread in the order in which they were performed. There is no guarantee of a single total ordering of volatile writes as seen from all threads of execution.

The volatile keyword can be applied to fields of these types:

• Reference types.
• Pointer types (in an unsafe context). Note that although the pointer itself can be volatile, the object that it points to cannot. In other words, you cannot declare a "pointer to volatile."
• Simple types such as sbytebyteshortushortintuintcharfloat, and bool.
• An enum type with one of the following base types: bytesbyteshortushortint, or uint.
• Generic type parameters known to be reference types.
• IntPtr and UIntPtr.

Other types, including double and long, cannot be marked volatile because reads and writes to fields of those types cannot be guaranteed to be atomic. To protect multi-threaded access to those types of fields, use the Interlocked class members or protect access using the lock statement.

The volatile keyword can only be applied to fields of a class or struct. Local variables cannot be declared volatile.

## Example

The following example shows how to declare a public field variable as volatile.

class VolatileTest
{
public volatile int sharedStorage;

public void Test(int _i)
{
sharedStorage = _i;
}
}


The following example demonstrates how an auxiliary or worker thread can be created and used to perform processing in parallel with that of the primary thread.

public class Worker
{
// This method is called when the thread is started.
public void DoWork()
{
while (!_shouldStop)
{
}
Console.WriteLine("Worker thread: terminating gracefully.");
}
public void RequestStop()
{
_shouldStop = true;
}
// Keyword volatile is used as a hint to the compiler that this data
// member is accessed by multiple threads.
private volatile bool _shouldStop;
}

{
public static void Main()
{
// Create the worker thread object. This does not start the thread.
Worker workerObject = new Worker();

// Start the worker thread.

// Loop until the worker thread activates.
;

// Put the main thread to sleep for 1 millisecond to
// allow the worker thread to do some work.

// Request that the worker thread stop itself.
workerObject.RequestStop();

// Use the Thread.Join method to block the current thread
// until the object's thread terminates.
}
// Sample output:
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: terminating gracefully.
// Main thread: worker thread has terminated.
}


With the volatile modifier added to the declaration of _shouldStop in place, you'll always get the same results (similar to the excerpt shown in the preceding code). However, without that modifier on the _shouldStop member, the behavior is unpredictable. The DoWork method may optimize the member access, resulting in reading stale data. Because of the nature of multi-threaded programming, the number of stale reads is unpredictable. Different runs of the program will produce somewhat different results.

Page structure