В настоящее время я читаю C++ "Параллельность в действии" Энтони Уильямса. Один из его списков показывает этот код, и он утверждает, что утверждение, что 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)
Может ли кто-нибудь объяснить мне, как это утверждение может срабатывать?
Он показывает этот маленький рисунок: 
read_x_then_y хранилище для 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 имеет значение true, а y по-прежнему false. После запуска write_y read_y_then_x прерывает свой цикл, однако оба значения x и y равны true, а z увеличивается, а утверждение не срабатывает. Я не могу думать ни о каком "прогоне" или порядке в памяти, где z никогда не увеличивается. Может кто-нибудь объяснить, где мои рассуждения ошибочны?
Кроме того, я знаю, что чтение цикла всегда будет перед чтением оператора if, потому что операция чтения предотвращает это переупорядочение.
