我目前正在阅读 Anthony Williams 撰写的《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)
有人可以向我解释一下这个断言是如何触发的吗？
He shows this little graphic:
商店不应该y也与负载同步read_x_then_y，以及商店x与负载同步read_y_then_x？我很困惑。
EDIT:
感谢您的回复，我了解原子是如何工作的以及如何使用获取/释放。我只是不明白这个具体的例子。我试图弄清楚如果断言触发，那么每个线程做了什么？如果我们使用顺序一致性，为什么断言永远不会触发。
顺便说一句，我对此的推理是，如果thread a (write_x) 存储到x那么到目前为止它所做的所有工作都会与读取的任何其他线程同步x与获取排序。一次read_x_then_y看到这个，它跳出循环并读取y。现在，可能会发生两件事。在一种选择中，write_y已写信给y，意味着此版本将与 if 语句（加载）含义同步z递增并且断言无法触发。另一种选择是如果write_y还没有运行，意味着 if 条件失败并且 z 没有增加，在这种情况下，仅x是真的并且y仍然是假的。一旦 write_y 运行，read_y_then_x 就会跳出循环，但是两者都x and y是真的并且z增加并且断言不会触发。我想不出任何“运行”或内存排序z永远不会增加。有人可以解释我的推理哪里有缺陷吗？
另外，我知道循环读取将始终在 if 语句读取之前，因为获取会阻止这种重新排序。
您正在考虑顺序一致性，即最强（也是默认）的内存顺序。如果采用这种内存顺序，所有对原子变量的访问构成全序，确实无法触发断言。
然而，在此程序中，使用了较弱的内存顺序（释放存储并获取加载）。根据定义，这意味着您cannot假设操作的总顺序。特别是，您不能假设更改以相同的顺序对其他线程可见。 （仅限总订单每个人变量保证任何原子内存顺序，包括memory_order_relaxed.)
各商店至x and y发生在不同的线程上，它们之间没有同步。的负载x and y发生在不同的线程上，它们之间没有同步。这意味着完全允许线程 c 看到x && ! y线程 d 看到y && ! x。 （我只是在这里缩写了 acquire-loads，不要将此语法视为顺序一致的加载。）
底线：一旦您使用比顺序一致性更弱的内存顺序，您就可以告别所有原子的全局状态的概念，即所有线程之间一致的概念。这正是为什么很多人建议坚持使用顺序一致性，除非您需要性能（顺便说一句，请记住测量它是否更快！）并且确定您在做什么。另外，征求第二意见。
现在，你是否会因此而受伤，是一个不同的问题。该标准只是根据用于描述标准要求的抽象机允许断言失败的场景。但是，您的编译器和/或 CPU 可能会出于某种原因而无法利用这一限额。因此，对于给定的编译器和 CPU，实际上您可能永远不会看到断言被触发。请记住，编译器或 CPU 可能始终使用stricter内存顺序比您要求的顺序要好，因为这永远不会违反标准的最低要求。它可能只会损失一些性能——但这并不包含在标准中。
更新回应评论：该标准没有定义一个线程看到另一个线程对原子的更改所需的时间的硬性上限。建议实施者价值观应该变得可见最终.
有测序保证，但与您的示例相关的保证不会阻止断言的触发。基本的获取-释放保证是如果：
x
x，对于 f 中的任何操作都是可见的，即在这个线程中，在给定负载之后排序。 [请注意，对于除这两个线程之外的线程，不提供任何保证！]因此，不能保证 fwill读取 e 存储的值，而不是 e.g.的一些旧值x. If it doesn't读取更新后的值，然后负载也会读取not与存储同步，并且对于上述任何相关操作都没有顺序保证。
我将原子比作与相对论一致的、具有较少内存顺序的原子，其中有没有同时性的全局概念 https://en.wikipedia.org/wiki/Ladder_paradox.
PS：也就是说，原子加载不能只读取任意旧值。例如，如果一个线程执行某个线程的周期性增量（例如，按释放顺序）atomic<unsigned>变量，初始化为 0，并且另一个线程定期从该变量加载（例如，使用获取顺序），那么，除了最终包装之外，后一个线程看到的值必须单调递增。但这是根据给定的排序规则得出的：一旦后一个线程读取了 5，则在从 4 增加到 5 之前发生的任何事情都处于读取 5 之后的任何事情的相对过去。事实上，除了换行之外的减少是甚至不允许memory_order_relaxed, but此内存顺序并不对访问其他变量的相对顺序（如果有）做出任何承诺。