Memoryorderconsume

Memory_order_consume is a memory ordering option defined for atomic operations in the C and C++ memory model. It is the weakest form of synchronization intended to use data dependencies rather than explicit cross-thread ordering to enforce visibility and ordering guarantees. When used on an atomic load, memory_order_consume ensures that subsequent operations that directly depend on the loaded value (for example, dereferencing a pointer obtained from the load to access further data) respect a happens-before relationship with that load.

In practice, memory_order_consume relies on the ability to propagate a data dependency through the program. If a value loaded from an atomic is used to compute or select other memory accesses, those dependent accesses must not be reordered before the consume load. However, the standard’s consumption model is hard to implement portably because compilers and architectures struggle to track data dependencies across optimization boundaries. As a result, on most platforms memory_order_consume behaves similarly to memory_order_acquire, or is effectively treated as stronger than intended. This has led to limited practical use of consume in real-world code.

Developers commonly prefer memory_order_acquire for consumer-side synchronization and memory_order_release for producer-side synchronization, paired to establish clear cross-thread data visibility. Because memory_order_consume offers ambiguous guarantees in practice, many codebases avoid relying on it and instead use acquire-release or stronger seq_cst ordering where appropriate.

See also memory_order, memory_order_acquire, memory_order_release, memory_order_relaxed, memory_order_seq_cst.