内存排序，指令重新排序和缺乏发生之前的关系(Memory ordering, instruction reordering and lack of happens-before relationship)

 轻松订购 
 
 用std :: memory_order_relaxed标记的原子操作不是同步操作; 只有线程之间共享每个原子对象的修改顺序。 不同的对象相对于其他线程之间没有排序; 操作可以看不到。 
 
 示例 - 轻松订购 
 
#include <atomic>
#include <thread>
#include <assert.h>
std::atomic<int> x{ 0 };
std::atomic<bool> x_is_set{ false };
std::atomic<int> counter{ 0 };
void f1()
{
    x.store(5, std::memory_order_relaxed);              // A
    x_is_set.store(true, std::memory_order_relaxed);    // B
}
void f2()
{
    while (!x_is_set.load(std::memory_order_relaxed));  // C

    if (x.load(std::memory_order_relaxed) == 5)         // D
        ++counter;                                      // E
}
int main()
{
    std::thread t1{ f1 };
    std::thread t2{ f2 };
    t1.join();
    t2.join();
    assert(counter.load() == 1);                        // F
}
 
 线程t1和线程t2之间没有排序约束。 因此，在A完成商店之前，可以通过t2看到在B中完成的商店; 在这种情况下，main（）中的断言F将触发。 
 
 这个问题的显而易见的解决方案是使B中的存储具有std::memory_order_release并且C中的加载具有std::memory_order_acquire用于同步目的。 F中的断言似乎永远不会发生。 
 
 题 
 
 但是，由于A和B之间没有发生之前的关系（我错了吗？），编译器/优化器/ CPU不能重新组织函数f1()的指令，以便B 在 A 之前排序吗？ 这将导致函数f2() C计算为true ，但D将为false ; 断言可以解雇。 
 
 是否存在阻止该问题产生的任何事情？ 

Relaxed ordering
 
Atomic operations tagged with std::memory_order_relaxed are not synchronization operations; only the modification order of each individual atomic object is shared between threads. Different objects have no ordering between themselves relative to other threads; operations can be seen out of order.
 
Example – Relaxed ordering
 
#include <atomic>
#include <thread>
#include <assert.h>
std::atomic<int> x{ 0 };
std::atomic<bool> x_is_set{ false };
std::atomic<int> counter{ 0 };
void f1()
{
    x.store(5, std::memory_order_relaxed);              // A
    x_is_set.store(true, std::memory_order_relaxed);    // B
}
void f2()
{
    while (!x_is_set.load(std::memory_order_relaxed));  // C

    if (x.load(std::memory_order_relaxed) == 5)         // D
        ++counter;                                      // E
}
int main()
{
    std::thread t1{ f1 };
    std::thread t2{ f2 };
    t1.join();
    t2.join();
    assert(counter.load() == 1);                        // F
}
 
There are no ordering constraints between thread t1 and thread t2. Therefore, the store done in B can be seen by t2 before the store done by A; the assert F in main() will fire in that case.
 
The obvious solution to this issue is to make the store in B have std::memory_order_release and the load in C have std::memory_order_acquire for synchronization purposes. The assert in F would seemingly never fire.
 
Question
 
However, since there is no happens-before relationship between A and B (am I wrong?), can't the compiler/optimizer/CPU reorganize the instructions in function f1() such that B is sequenced-before A? This would cause C in function f2() to evaluate to true, but D would be false; the assert could fire.
 
Is there anything preventing that issue from arising?

原文：https://stackoverflow.com/questions/32574459