атомарные записи и непостоянные чтения

На всех платформах, которые вы, вероятно, будете использовать, которые поддерживают C ++ и несколько потоков, чтение из выровненного int с изменяемым кодом будет атомарным и будет считывать последнее значение. Однако это абсолютно не гарантируется стандартом C ++. Может быть какая-то платформа, на которой он не работает, и он может не работать со следующим ЦП, версией компилятора или версией ОС.

В идеале используйте что-то, что гарантированно обеспечивает атомарность и видимость. C ++ - 11 atomic, вероятно, лучший выбор. Следующим лучшим выбором будут внутренние компоненты компилятора. Если у вас нет другого выбора, кроме как просто использовать volatile, я бы посоветовал вам использовать тесты препроцессора, чтобы подтвердить, что вы находитесь на платформе, где этого достаточно, и выдать ошибку (с #error), если нет.

Обратите внимание, что на каждой платформе, которую вы, вероятно, будете использовать, кеши памяти ЦП совершенно неактуальны, потому что они становятся невидимыми из-за согласованности аппаратного кеша. На всех платформах, которые вы, вероятно, будете использовать, проблемы связаны только с оптимизацией компилятора, предварительно выбранными чтениями и опубликованными записями.

Ключевое слово volatile только гарантирует, что компилятор не будет сохранять переменную в регистре, а вместо этого будет загружать переменную из памяти каждый раз, когда она используется. Это не имеет ничего общего с моделями согласованности кеша или памяти системы, в которой он работает.

volatile не делает операции чтения атомарными. Неатомарное чтение, одновременное с (атомарной) записью, приводит к неопределенному поведению. Используйте атомарное чтение в любой форме, std::atomic или внутреннее. Не используйте volatile для какой-либо формы параллелизма.

Само по себе атомарное чтение не гарантирует, что значение будет последним. В вашем случае поток T2 может никогда не прочитать 100 теоретически. В стандарте говорится, что реализация (оборудование, ОС и т. Д.) Должна делать все возможное, чтобы сделать запись видимой для других потоков за конечное время. Пожалуй, здесь невозможно поставить формальные требования.

С дополнительной синхронизацией вы можете добиться более ограниченного поведения:

std::atomic<int> a = 10;
std::atomic<bool> done = false;

void func_1() {
    int old = 10;
    if (a.compare_exchange_strong(old, 100))
        done.store(true);
}

void func_2() {
    bool is_done = done.load();
    int b = a.load();
    assert(b == 100 || !is_done);

    while (!done.load()); // May spin indefinitely long, but should not do that
    assert(a.load() == 100);
}

На самом деле, чтобы поймать, что простое атомарное чтение читает не значение latest, нужно было бы добавить в программу достаточную синхронизацию (чтобы определить latest), чтобы она работала правильно. .