All Atomics and Memory Ordering

All Atomics and Memory Ordering

A compact scan page for standard atomic types, operations, fences, and memory-order vocabulary.

How to use this reference page

Use reference pages to confirm names, categories, nearby facilities, and the constraints that matter before writing or reviewing code.

Scan the top of the page first to identify the primary types, functions, or algorithm families involved.
Use the nearby-page links when your question is really about a companion header, related algorithm family, or broader subsystem.
Validate tricky behavior with a small compileable example before relying on memory for details like invalidation, ordering, allocation, or lifetime rules.

All Atomics and Memory Ordering

Core atomic types

std::atomic<T>
std::atomic_flag
std::atomic_ref<T>

Common atomic operations

load
store
exchange
compare_exchange_weak
compare_exchange_strong
fetch_add, fetch_sub
fetch_and, fetch_or, fetch_xor
wait, notify_one, notify_all

Fences and lock-free queries

std::atomic_thread_fence
std::atomic_signal_fence
is_lock_free
is_always_lock_free

Memory-order vocabulary

std::memory_order
memory_order_relaxed
memory_order_consume
memory_order_acquire
memory_order_release
memory_order_acq_rel
memory_order_seq_cst

Practical rules

Start with mutexes unless atomics solve a measured problem more cleanly.
Use seq_cst until you can justify weaker orders precisely.
Treat acquire/release protocols as shared invariants that deserve documentation and tests.

Example in practice

#include <atomic>
#include <thread>

int main() {
    std::atomic<bool> ready{false};
    int value = 0;

    std::jthread producer([&] {
        value = 42;
        ready.store(true, std::memory_order_release);
    });

    while (!ready.load(std::memory_order_acquire)) {
    }

    return value == 42 ? 0 : 1;
}