std::atomic + memory model

std::atomic<T> — шаблонный тип из <atomic>, операции над которым (load, store, fetch_add, compare_exchange и т.д.) гарантированно неделимы (atomic) с точки зрения других потоков — нет промежуточного состояния, которое можно было бы наблюдать. Вместе с типом стандарт вводит формальную модель памяти: строгое определение data race как undefined behavior и отношение happens-before, определяющее, когда запись одного потока гарантированно видна чтению другого.std::atomic<T> is a template type from <atomic> whose operations (load, store, fetch_add, compare_exchange, etc.) are guaranteed indivisible (atomic) from the point of view of other threads — there's no intermediate state that could be observed. Alongside the type, the standard introduces a formal memory model: a strict definition of data races as undefined behavior, and the happens-before relation, which determines when a write on one thread is guaranteed visible to a read on another.

// volatile int flag; — НЕ синхронизация, только запрет// volatile int flag; — NOT synchronization, only suppresses
// оптимизации компилятора на конкретной переменной;// compiler optimizations on that specific variable;
// не даёт memory ordering между потоками// gives no memory ordering between threads

std::atomic<bool> ready{false};
// store/load с заданным memory_order —// store/load with an explicit memory_order —
// формально специфицированное поведение// formally specified behavior
// относительно других потоков// with respect to other threads

Формальная модель памяти была необходима не как удобство, а как условие корректности любого многопоточного кода:A formal memory model wasn't a nicety — it was a precondition for the correctness of any multithreaded code:

Подробный разбор memory_order (relaxed/acquire/release/seq_cst), паттерна публикации данных через atomic-флаг, false sharing и SPSC lock-free очередей — в cpp_concurrency.md. Здесь — происхождение фичи и базовый пример: атомарная запись данных с release, атомарное чтение флага с acquire формируют happens-before, которая гарантирует видимость записанных данных.A detailed breakdown of memory_order (relaxed/acquire/release/seq_cst), the data-publication pattern via an atomic flag, false sharing, and SPSC lock-free queues lives in cpp_concurrency.md. Here it's just the feature's origin and a basic example: an atomic store of the data with release, and an atomic load of the flag with acquire, together form a happens-before relation that guarantees visibility of the written data.

#include <atomic>

std::atomic<bool> ready{false};
int data = 0;

// producer:// producer:
void produce() {
    data = 42;                                    // обычная запись// an ordinary write
    ready.store(true, std::memory_order_release);  // публикация// publication
}

// consumer:// consumer:
void consume() {
    while (!ready.load(std::memory_order_acquire)) {} // ждём публикации// wait for publication
    use(data);   // гарантированно видит data == 42 — release/acquire// guaranteed to see data == 42 — release/acquire
                 // формируют happens-before между потоками// form a happens-before relation between threads
}

Без пары release/acquire (например, если использовать memory_order_relaxed для обеих операций) чтение data в consumer было бы data race — undefined behavior, а не просто «может прочитать старое значение».Without the release/acquire pair (for example, using memory_order_relaxed for both operations), reading data in the consumer would be a data race — undefined behavior, not merely "might read a stale value."

• cppreference — std::atomic
• cppreference — std::memory_order
• WG21 N2429 — Memory Model Rationale