问题描述
我最近了解了c ++的六个内存顺序,我对memory_order_acquire
和memory_order_release
感到非常困惑,这是cpp的示例:
#include <thread>
#include <atomic>
#include <cassert>
std::atomic<bool> x = {false};
std::atomic<bool> y = {false};
std::atomic<int> z = {0};
void write_x() { x.store(true,std::memory_order_seq_cst); }
void write_y() { y.store(true,std::memory_order_seq_cst); }
void read_x_then_y() {
while (!x.load(std::memory_order_seq_cst));
if (y.load(std::memory_order_seq_cst))
++z;
}
void read_y_then_x() {
while (!y.load(std::memory_order_seq_cst));
if (x.load(std::memory_order_seq_cst))
++z;
}
int main() {
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); // will never happen
}
此示例说明了需要顺序排序的情况。
任何其他顺序都可能触发断言,因为这可能 让线程c和d观察到原子x和y的变化 相反的顺序。
所以我的问题是,为什么不能在此处使用 memory_order_acquire 和 memory_order_release ?并且memory_order_acquire和memory_order_release提供什么语义?
一些参考: https://en.cppreference.com/w/cpp/atomic/memory_order https://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync
解决方法
顺序一致性为所有顺序一致的操作提供了单个总订单。因此,如果您在线程A中有一个顺序一致的存储,而在线程B中有一个顺序一致的加载,并且存储在加载之前被排序(按照所述单个总顺序),那么B会观察到A所存储的值。保证存储对其他线程“直接可见”。发行商店不不提供此保证。
正如彼得·科德斯(Peter Cordes)正确指出的那样,术语“立即可见”相当不精确。 “可见性”源于以下事实:所有seq-cst操作都是完全有序的,并且所有线程都遵守该顺序。由于存储和加载是完全有序的,因此在执行后续加载(按单个总顺序)之前,存储的值变得可见。
在不同线程中的获取/释放操作之间不存在这种总顺序,因此无法保证可见性。仅当获取操作观察到释放操作的值后,才对操作进行排序,但是不能保证何时对执行获取操作的线程可见释放操作的值。
让我们考虑一下在此示例中使用获取/发布时会发生什么:
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() {
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); // can actually happen!!
}
由于我们无法保证可见性,因此线程c
可以观察到x == true
和y == false
,而线程d
可以观察到{{1 }}和y == true
。因此,两个线程都不会递增x == false
,并且断言也会触发。
有关C ++内存模型的更多详细信息,我可以推荐我与他人合着的这篇论文:Memory Models for C/C++ Programmers
,将信息从一个线程传递到另一个线程时,可以使用aquire / release-这是最常见的情况。无需对此有连续的要求。
在此示例中,有一堆线程。两个线程进行写操作,而第三个线程则粗略测试x
之前是否准备好y
,而第四个线程则测试y
之前是否已经准备好x
。从理论上讲,一个线程可以观察到x
在y
之前被修改,而另一个线程则看到y
在x
之前被修改。不能完全确定它的可能性。这是一个不常见的用例。
编辑:您可以直观地看到示例:假定每个线程都在不同的PC上运行,并且它们通过网络进行通信。每对PC的ping互不相同。在这里很容易举一个例子,其中不清楚哪个事件首先发生在x
或y
上,因为每个PC会看到事件以不同的顺序发生。
我不确定在哪种架构上可能会发生这种影响,但是在复杂的架构中,两个不同的处理器联合在一起。当然,处理器之间的通信比每个处理器内核之间的通信要慢。