тоящее время я читаю C ++ Concurrency in Action Энтони Уильямса. Один из его списков показывает этот код, и он утверждает, что утверждениеz != 0 могу стрелять

#include <atomic>
#include <thread>
#include <assert.h>

std::atomic<bool> x,y;
std::atomic<int> z;

void write_x()
{
    x.store(true,std::memory_order_release);
}

void write_y()
{
    y.store(true,std::memory_order_release);
}

void read_x_then_y()
{
    while(!x.load(std::memory_order_acquire));
    if(y.load(std::memory_order_acquire))
        ++z;
}

void read_y_then_x()
{
    while(!y.load(std::memory_order_acquire));
    if(x.load(std::memory_order_acquire))
        ++z;
}

int main()
{
    x=false;
    y=false;
    z=0;
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x);
    a.join();
    b.join();
    c.join();
    d.join();
    assert(z.load()!=0);
}

Итак, различные пути выполнения, о которых я могу думать, таковы:

1)

Thread a (x is now true)
Thread c (fails to increment z)
Thread b (y is now true)
Thread d (increments z) assertion cannot fire

2)

Thread b (y is now true)
Thread d (fails to increment z)
Thread a (x is now true)
Thread c (increments z) assertion cannot fire

3)

Thread a (x is true)
Thread b (y is true)
Thread c (z is incremented) assertion cannot fire
Thread d (z is incremented)

Может ли кто-нибудь объяснить мне, как это утверждение может срабатывать?

Он показывает этот маленький рисунок:

Разве магазин не долженy также синхронизировать с нагрузкой вread_x_then_yи магазин вx синхронизировать с нагрузкой вread_y_then_x? Я очень смущен.

РЕДАКТИРОВАТЬ:

Спасибо за ваши ответы, я понимаю, как работает атомика и как использовать Acquire / Release. Я просто не понимаю этот конкретный пример. Я пытался выяснить, ЕСЛИ утверждение срабатывает, то что делал каждый поток? И почему утверждение никогда не срабатывает, если мы используем последовательную согласованность.

Кстати, я рассуждаю об этом, что еслиthread a (write_x) магазины вx тогда вся работа, которую он проделал, синхронизируется с любым другим потоком, который читаетx с приобретением заказа. однаждыread_x_then_y видит это, он выходит из цикла и читаетy, Теперь 2 вещи могут произойти. В одном вариантеwrite_y написалyЭто означает, что этот выпуск будет синхронизирован с оператором if (load)z увеличивается, и утверждение не может срабатывать. Другой вариант, еслиwrite_y еще не запущен, что означает, что условие if не выполняется и z не увеличивается, в этом сценарии толькоx это правда иy все еще ложь. После запуска write_y read_y_then_x прерывает цикл, однако обаx а такжеy верны иz увеличивается и утверждение не срабатывает. Я не могу думать о каком-либо «беге» или упорядочении памяти, гдеz никогда не увеличивается. Может кто-нибудь объяснить, где мои рассуждения ошибочны?

Кроме того, я знаю, что чтение цикла всегда будет перед чтением оператора if, потому что операция чтения предотвращает это переупорядочение.