C ++ memory_order_acquire / release问题

如何解决C ++ memory_order_acquire / release问题

我最近了解了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
}

在cpp参考页面中，显示：

此示例说明了需要顺序排序的情况。

任何其他顺序都可能触发断言，因为这可能 让线程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会看到事件以不同的顺序发生。

我不确定在哪种架构上可能会发生这种影响，但是在复杂的架构中，两个不同的处理器联合在一起。当然，处理器之间的通信比每个处理器内核之间的通信要慢。