Home/ Questions/Q 57287
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-10T17:40:03+00:00

In the C programming language and Pthreads as the threading library; do variables/structures that

  • 0

In the C programming language and Pthreads as the threading library; do variables/structures that are shared between threads need to be declared as volatile? Assuming that they might be protected by a lock or not (barriers perhaps).

Does the pthread POSIX standard have any say about this, is this compiler-dependent or neither?

Edit to add: Thanks for the great answers. But what if you’re not using locks; what if you’re using barriers for example? Or code that uses primitives such as compare-and-swap to directly and atomically modify a shared variable…

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. I think one very important property of volatile is that it makes the variable be written to memory when modified, and reread from memory each time it accessed. The other answers here mix volatile and synchronization, and it is clear from some other answers than this that volatile is NOT a sync primitive (credit where credit is due).

    But unless you use volatile, the compiler is free to cache the shared data in a register for any length of time… if you want your data to be written to be predictably written to actual memory and not just cached in a register by the compiler at its discretion, you will need to mark it as volatile. Alternatively, if you only access the shared data after you have left a function modifying it, you might be fine. But I would suggest not relying on blind luck to make sure that values are written back from registers to memory.

    Especially on register-rich machines (i.e., not x86), variables can live for quite long periods in registers, and a good compiler can cache even parts of structures or entire structures in registers. So you should use volatile, but for performance, also copy values to local variables for computation and then do an explicit write-back. Essentially, using volatile efficiently means doing a bit of load-store thinking in your C code.

    In any case, you positively have to use some kind of OS-level provided sync mechanism to create a correct program.

    For an example of the weakness of volatile, see my Decker’s algorithm example at http://jakob.engbloms.se/archives/65, which proves pretty well that volatile does not work to synchronize.

    • 0