atomicload

Atomic load, often called atomic_load, is a concurrency primitive used to read the value stored in an atomic object without introducing data races. The operation retrieves the current value held by the atomic object in a manner that is indivisible from other threads’ views of memory. This means the read cannot return a partially updated value and participates in the program’s synchronization scheme.

Memory ordering is a key aspect of atomic_load. Different memory orderings control how the read is synchronized with other operations. Common options include relaxed, acquire, and sequentially consistent (seq_cst). A load with acquire semantics ensures that subsequent reads and writes in the thread cannot be reordered before the load, providing a happens-before relationship with certain stores. Seq_cst imposes a global, total order of such operations, simplifying reasoning about concurrent interactions. Relaxed ordering offers atomicity without enforcing ordering constraints, suitable for counters or flags where a precise ordering is unnecessary.

Language variants exist. In C11 and later, atomic_load reads from an _Atomic object and can be expressed explicitly as atomic_load_explicit(object, order) or using a default atomic_load for seq_cst behavior. In C++, std::atomic<T>::load(memory_order) provides a similar capability, with a default of memory_order_seq_cst when no argument is supplied.

Usage and considerations. Atomic_load is commonly used to read shared state protected by atomics or to observe a flag or pointer without locking. Correct use often pairs a load with acquire semantics on stores to establish proper synchronization. Developers should choose memory ordering based on the needed visibility guarantees and performance considerations, balancing safety with efficiency.