Is Volatile Still Relevant in C 11\'s Multi-threaded World?

Volatile in C 11: A Deprecated Problem?

The C 11 standard introduced a significant shift in its machine model, transitioning from a single-threaded to a multi-threaded approach. This raises the question: does this change eliminate the potential for the notorious "read optimization" issue, where a static variable read within a while loop is optimized out?

The Problem with Read Optimization

In a multi-threaded environment, it is crucial to consider the potential for concurrent access to variables. In C , the keyword volatile can be used to inform the compiler that a variable cannot be optimized away. This ensures that the variable is always read from memory, even when the compiler would otherwise assume its value remains unchanged.

In the case of the classic example static int x; void func() { x = 0; while (x == 0) {} }, the optimizer may assume that x remains zero throughout the loop and eliminate the loop entirely. However, if another thread modifies x concurrently, the loop will not terminate, leading to unpredictable behavior.

Volatile and the C 11 Memory Model

While the C 11 memory model does recognize the possibility of concurrent access to variables, it does not mandate atomic operations. Non-atomic access to variables constitutes undefined behavior.

This means that even in C 11, using volatile does not address the underlying problem of thread safety. The memory model requires specific synchronization mechanisms, such as mutexes or atomic operations, to establish explicit ordering and visibility between threads.

Volatile serves a different purpose. It prevents the compiler from optimizing away memory reads, ensuring that the most up-to-date value is always fetched from memory. However, it does not address the issue of ensuring data integrity across threads.

The above is the detailed content of Is Volatile Still Relevant in C 11\'s Multi-threaded World?. For more information, please follow other related articles on the PHP Chinese website!