Что такое модель памяти C++11 и как она влияет на многопоточное программирование?

Краткий ответ: почему ваш код может сломаться

Да, компилятор и процессор могут переставить операции местами. На одном ядре порядок кажется сохранённым, но в многопоточной среде другой поток может увидеть ready = true раньше, чем shared_data = 42. Это происходит из-за двух вещей:

• Оптимизации компилятора: он может переупорядочить инструкции для улучшения конвейеризации или регистрового использования.
• Аппаратное переупорядочивание: процессоры (особенно ARM, PowerPC) могут выполнять записи не в том порядке, в котором они написаны в коде, ради производительности.

Модель памяти C++11 — это набор правил, которые определяют, какие перестановки операций допустимы, а какие — нет, и какие гарантии даются при работе с разными типами данных.

Что такое модель памяти C++11?

Это формальное описание того, как потоки взаимодействуют через общую память. Она вводит:

• Атомарные типы (std::atomic<T>) — операции над ними не разрываются переключением контекста.
• Порядки памяти (memory orders) — шесть режимов, от memory_order_relaxed (без гарантий порядка) до memory_order_seq_cst (строгий последовательный порядок, по умолчанию).
• Правила happens-before — если операция A happens-before B, то результат A виден в B.

Как исправить ваш код?

Используйте атомарные переменные с правильным порядком памяти. Самый простой способ — std::atomic со строгим порядком (по умолчанию):

#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> shared_data(0);
std::atomic<bool> ready(false);

void writer() {
    shared_data.store(42, std::memory_order_release); // Шаг 1
    ready.store(true, std::memory_order_release);     // Шаг 2
}

void reader() {
    while (!ready.load(std::memory_order_acquire));   // Ждем
    std::cout << shared_data.load(std::memory_order_acquire) << std::endl;
}

Объяснение на пальцах

Представьте, что у вас есть две коробки: одна с данными (shared_data), другая с флагом (ready). Без барьеров (release/acquire) курьер может доставить флаг раньше данных. memory_order_release — это как подпись на коробке: "все мои предыдущие записи должны быть видны до того, как кто-то увидит эту запись". memory_order_acquire — это как проверка подписи: "я не буду читать другие данные, пока не увижу эту запись".

Вместе они образуют синхронизацию: writer гарантирует, что shared_data будет записана до ready, а reader — что прочитает shared_data только после того, как увидит ready = true.

Что ещё важно знать?

• std::memory_order_seq_cst (по умолчанию) даёт максимальные гарантии, но может быть медленнее на некоторых архитектурах.
• Для простых флагов и счётчиков используйте std::atomic<bool> и std::atomic<int> — они работают эффективно.
• Не используйте volatile для синхронизации — это не про многопоточность, а про отключение оптимизаций для регистров.

Модель памяти C++11 — это не страшно. Это просто инструмент, который говорит компилятору и процессору: "здесь нельзя переставлять операции, потому что это сломает логику".

std::atomic<bool> ready(false);
int shared_data = 0;

void writer() {
    shared_data = 42;
    std::atomic_thread_fence(std::memory_order_release);
    ready.store(true, std::memory_order_relaxed);
}

void reader() {
    while (!ready.load(std::memory_order_relaxed));
    std::atomic_thread_fence(std::memory_order_acquire);
    std::cout << shared_data << std::endl;
}