C++ Memory Order

C++11 Memory Order

为什么需要Memory Order

多线程下可能影响程序执行结果的行为：

• 原子操作（简单语句，C++也不保证是原子操作)
• 指令执行顺序（编译器可能优化代码使代码顺序发生变化，CPU可能会调整指令执行顺序）
• CPU可见性（再CPU cache的影响下，可能存在一个CPU执行了某个指令，不会立即被其他CPU所见）

例子1

int64_t i = 0;
// Thread-1
i = 100;

// Thread2
std::cout << i;

上面的代码输出可能是一个未定义的行为，由于不同CPU结构对指令的处理也不同，有的CPU再处理64为字节时需要两条指令，那这样i就不是原子操作，Thread-1和Thread-2的行为就变成了未定义.

例子2

std::atomic<int> x{0};
std::atomic<int> y{0};

// Thread-1:
x.store(100, std::memory_order_relaxed);
y.store(200, std::memory_order_relaxed);

// Thread-2:
while (y.load(std::memory_order_relaxed) != 200)
    ;
std::cout << x.load(std::memory_order_relaxed);

上面的例子，线程1对x和y分别写入100，200，并且x, y的操作属于原子操作，线程2等待y变成200之后，输出x的值，在这里x的值可能是0，由于再多线程下并没有保证指令指令顺序的一致性，所以上面的顺序是两个字：任意，那y.strore就可能执行再x.stroe的前面，导致x输出0.

例子3

int x = 0;

// Thread-1:
x = 100;    // A

// Thread-2:
std::cout << x; // B

现在假设A在B之前执行，x的可能输出是多少？

ｘ可能输出0，100，由于CPU可见性的问题，可能Thread-1中的A操作执行完，x的值还在高速缓存上，并没有更新到内存，之后Thread-2中的B去读取x的值就读取到了旧值.

以上三个例子分别对应的三种可能改变程序执行结果的行为(多线程下)，C++11 memory order就是解决以上的问题，让C++用户写多线程程序时不需要考虑机器环境（这个时C++11 memory model功劳), 在C++11中可以提供了mutex，std::atomic...

C++11 std::atomic

c11 的顺序格式如下：

• Relaxed ordering
• Release_Acquire ordering
• Release_Consume ordering
• Sequentially-consistent ordering

分别对应了std::atomic中的顺序如下:

• std::memory_order_relaxed
• std::memory_order_acquire
• std::memory_order_release
• std::memory_order_consume
• std::memory_acq_rel
• std::memory_seq_cst

Relaxed ordering

std::atomic<int> x = 0;
std::atomic<int> y = 0;

// 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.stroe(99, memory_order_relaxed);  // D

r1 == r2 == 99可能出现吗？

可能的， D->A->B->C的执行顺序就可能出现r1 == r2 == 99

解释： Relaxed ordering仅仅只保证atomic自带的方法是原子操作，除此之外，不提供任何跨线程的同步，由于不提供任何跨线程的同步，所以上面例子中的执行顺序就是两个字：任意，但是Relaxed ordering好处也非常明显，就是性能高.

Release-Acquire ordering

在这种模型下，load()采用memory_order_acquire, store()采用memory_order_release，提供了两个线程之间的主要功能.

1.限制指令重排

• 在store()之前的所有读写操作，不允许被移动到这个store()的后面.
• 在load()之后的所有读写操作，不允许被移动到这个load()前面.

2.线程之前可见

线程之间由于Cpu cache，导致线程之间不可见，Release-Acquire提供了线程之间的可见.

std::atomic<bool> ready{false};
int data = 0;
void producer() {
    data = 10;                                      // A
    ready.store(true, std::memroy_order_release);   // B
}

void consumer() {
    while (!ready.load(std::memory_order_acquire))  // C
        ;
    assert(data == 100);                            // D
}

int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
}

上面例子中assert永远不会触发，根据上面的指令限制规则，A不可能移动到B的后面，D不可能移动到C的前面.

std::atomic<bool> f1 = false;
std::atomic<bool> f2 = false;

// thread1
f1.store(true, memroy_order_release);   // A
if (!f2.load(memory_order_acquire)) {   // B
    // critical section
}

//thread2
f2.store(true, memroy_order_release);   // C
if (!f1.load(memory_order_acquire)) {   // D
    // critical section
}

上面例子中两个if条件可能同时满足，并且同时进入临界区，根据上面的指令规则，B可以移动到A的前面，D可以移动到C的前面，这都不违法规则.

Release-Consume ordering

Release-Consume相比Release-Acquire，在功能上弱了一点，它仅仅将依赖于x（假设）的值进行同步.

Sequential consisten ordering

Release-Acquire就同步一个x，顺序一致会对所有的变量的所有原子操作都同步，这样，所有的原子操作就跟由一个线程执行似的.