无锁编程：重新排序和内存顺序语义

Question

我正在尝试在无锁编程中立足。在阅读了关于内存排序语义的不同解释后，我想澄清一下可能发生的重新排序。据我了解，编译器（由于编译程序时的优化）和CPU（在运行时？）可能会重新排序指令。

对于宽松语义cpp reference 提供以下示例：

// Thread 1:
r1 = y.load(memory_order_relaxed); // A
x.store(r1, memory_order_relaxed); // B
// Thread 2:
r2 = x.load(memory_order_relaxed); // C 
y.store(42, memory_order_relaxed); // D

据说在 x 和 y 初始为零时，代码可以产生 r1 == r2 == 42，因为虽然 A 在线程 1 中排在 B 之前，C 在线程 2 中排在 D 之前，但没有什么可以阻止D 以 y 的修改顺序出现在 A 之前，B 以 x 的修改顺序出现在 C 之前。怎么会这样？这是否意味着 C 和 D 被重新排序，所以执行顺序是 DABC？是否允许重新排序 A 和 B？

对于获取-释放语义，有以下示例代码：

std::atomic<std::string*> ptr;
int data;

void producer()
{
    std::string* p  = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}

void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_acquire)))
        ;
    assert(*p2 == "Hello"); // never fires
    assert(data == 42); // never fires
}

我想知道如果我们使用宽松的内存顺序而不是获取呢？我猜data的值可以在p2 = ptr.load(std::memory_order_relaxed)之前读取，但是p2呢？

最后，为什么在这种情况下可以使用宽松的内存顺序？

template<typename T>
class stack
{
    std::atomic<node<T>*> head;
 public:
    void push(const T& data)
    {
      node<T>* new_node = new node<T>(data);

      // put the current value of head into new_node->next
      new_node->next = head.load(std::memory_order_relaxed);

      // now make new_node the new head, but if the head
      // is no longer what's stored in new_node->next
      // (some other thread must have inserted a node just now)
      // then put that new head into new_node->next and try again
      while(!head.compare_exchange_weak(new_node->next, new_node,
                                        std::memory_order_release,
                                        std::memory_order_relaxed))
          ; // the body of the loop is empty
    }
};

我的意思是head.load(std::memory_order_relaxed) 和head.compare_exchange_weak(new_node->next, new_node, std::memory_order_release, std::memory_order_relaxed)。

总结以上所有内容，我的问题本质上是我什么时候需要关心潜在的重新排序，什么时候不需要？

Answer 1

对于#1，编译器可能会在从 x 加载之前向 y 发出存储（没有依赖关系），即使没有，从 x 加载也可以在 cpu/内存级别延迟。

对于#2，p2 将不为零，但 *p2 和 data 都不一定具有有意义的值。

对于#3，这个线程只有一个发布非原子存储的行为，它是一个发布

您应该始终关心重新排序，或者最好不要假设任何顺序：C++ 和硬件都不会从上到下执行代码，它们只尊重依赖关系。