When and how to use the volatile keyword in C#

In multi-threaded programming, there can be issues with the consistency and visibility of data between threads. The volatile keyword is used to indicate that a variable’s value might be modified by multiple threads simultaneously, and that any change made to that variable should be immediately visible to all threads.

Consider the following scenario:

class Program
{
    static bool isRunning = true;
    
    static void Main(string[] args) {
        Task.Run(() => StopProgram());
        
        while (isRunning)
        {
            // do some work
        }
        
        Console.WriteLine("Program stopped.");
    }
    
    static void StopProgram() {
        Thread.Sleep(5000);
        isRunning = false;
    }
}

In this example, we have a program that runs a loop while a boolean variable isRunning is true. We also have another thread that is responsible for stopping the program by setting isRunning to false after a delay of 5 seconds.

The issue with this code is that the loop may not exit when the isRunning value is changed by the other thread because the value is cached by the CPU’s registers or by the compiler’s optimizations. To fix this issue, we can use the volatile keyword as follows:

class Program
{
    static volatile bool isRunning = true;
    
    static void Main(string[] args) {
        Task.Run(() => StopProgram());
        
        while (isRunning)
        {
            // do some work
        }
        
        Console.WriteLine("Program stopped.");
    }
    
    static void StopProgram() {
        Thread.Sleep(5000);
        isRunning = false;
    }
}

By adding the volatile keyword to the isRunning variable, we ensure that its value is always read from memory and that any changes made to it are immediately visible to all threads. This ensures that the loop will exit when the isRunning value is changed by the other thread.

In summary, the volatile keyword is used to ensure that the value of a variable is immediately visible to all threads, preventing issues with data consistency and visibility in multi-threaded programming.