When to use volatile with multi threading?

by

Short & quick answer: volatile is (nearly) useless for platform-agnostic, multithreaded application programming. It does not provide any synchronization, it does not create memory fences, nor does it ensure the order of execution of operations. It does not make operations atomic. It does not make your code magically thread safe. volatile may be the single-most misunderstood facility in all of C++. See this, this and this for more information about volatile

On the other hand, volatile does have some use that may not be so obvious. It can be used much in the same way one would use const to help the compiler show you where you might be making a mistake in accessing some shared resource in a non-protected way. This use is discussed by Alexandrescu in this article. However, this is basically using the C++ type system in a way that is often viewed as a contrivance and can evoke Undefined Behavior.

volatile was specifically intended to be used when interfacing with memory-mapped hardware, signal handlers, and the setjmp machine code instruction. This makes volatile directly applicable to systems-level programming rather than normal applications-level programming.

The 2003 C++ Standard does not say that volatile applies any kind of Acquire or Release semantics on variables. In fact, the Standard is completely silent on all matters of multithreading. However, specific platforms do apply Acquire and Release semantics on volatile variables.

[Update for C++11]

The C++11 Standard now does acknowledge multithreading directly in the memory model and the language, and it provides library facilities to deal with it in a platform-independent way. However the semantics of volatile still have not changed. volatile is still not a synchronization mechanism. Bjarne Stroustrup says as much in TCPPPL4E:

Do not use volatile except in low-level code that deals directly
with hardware.

Do not assume volatile has special meaning in the memory model. It
does not. It is not — as in some later languages — a
synchronization mechanism. To get synchronization, use atomic, a
mutex, or a condition_variable.

[/End update]

The above all applies to the C++ language itself, as defined by the 2003 Standard (and now the 2011 Standard). Some specific platforms however do add additional functionality or restrictions to what volatile does. For example, in MSVC 2010 (at least) Acquire and Release semantics do apply to certain operations on volatile variables. From the MSDN:

When optimizing, the compiler must maintain ordering among references
to volatile objects as well as references to other global objects. In
particular,

A write to a volatile object (volatile write) has Release semantics; a
reference to a global or static object that occurs before a write to a
volatile object in the instruction sequence will occur before that
volatile write in the compiled binary.

A read of a volatile object (volatile read) has Acquire semantics; a
reference to a global or static object that occurs after a read of
volatile memory in the instruction sequence will occur after that
volatile read in the compiled binary.

However, you might take note of the fact that if you follow the above link, there is some debate in the comments as to whether or not acquire/release semantics actually apply in this case.

More Related Contents:

  1. Can num++ be atomic for ‘int num’?
  2. Why is integer assignment on a naturally aligned variable atomic on x86?
  3. Why is volatile not considered useful in multithreaded C or C++ programming?
  4. Concurrency: Atomic and volatile in C++11 memory model
  5. Lock-free Progress Guarantees in a circular buffer queue
  6. Understanding std::hardware_destructive_interference_size and std::hardware_constructive_interference_size
  7. Atomicity on x86
  8. What exactly is std::atomic?
  9. How to implement multithread safe singleton in C++11 without using
  10. Mixing C++11 atomics and OpenMP
  11. Does the C++ volatile keyword introduce a memory fence?
  12. Circular lock-free buffer
  13. Is volatile bool for thread control considered wrong?
  14. How to atomically update a maximum value?
  15. Why is the volatile qualifier used through out std::atomic?
  16. Do I need to protect read access to an STL container in a multithreading environment?
  17. c++, std::atomic, what is std::memory_order and how to use them?
  18. Making a C++ class a Monitor (in the concurrent sense)
  19. Understanding std::atomic::compare_exchange_weak() in C++11
  20. Are C/C++ fundamental types atomic?
  21. Double-Checked Lock Singleton in C++11
  22. Atomically increment two integers with CAS
  23. Is ‘volatile’ needed in this multi-threaded C++ code?
  24. Is a memory barrier required to read a value that is atomically modified?
  25. Acquire/Release versus Sequentially Consistent memory order
  26. Passing object by reference to std::thread in C++11
  27. How to use std::async on a member function?
  28. Which types on a 64-bit computer are naturally atomic in gnu C and gnu C++? — meaning they have atomic reads, and atomic writes
  29. What is different between join() and detach() for multi threading in C++?
  30. Does std::mutex create a fence?

Leave a Comment