В настоящее время я читаю 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, потому что операция чтения предотвращает это переупорядочение.