引言

在C++多线程内存序系列文章中，已经介绍了如下三种内存序

C++11多线程内存序(std::memory_order_seq_cst )

C++11多线程内存序(std::memory_order_acquire/release)

C++11多线程内存序(std::memory_order_relaxed)

为了保持该系列文章的完整性，因此增加std::memory_order_consume的介绍。

std::memory_order_consume仅仅只用来补充该系列的完整性，在实际代码中不能使用该内存序，且在GCC中会自动将该内存序转换为std::memory_order_acquire。参考至Fixing GCC's Implementation of memory_order_consume

data dependency介绍

要理解和使用std::memory_order_consume，需要先理解什么是data dependency。在C++中data dependency可分为如下两种：

carries-a-dependency-to: if the result of operation A is used as an operand in operation B, then: A carries-a-dependency-to B.

dependency-ordered-before: a store operation (with std::memory_order_release, std::memory_order_acq_rel, or std::memory_order_seq_cst) is dependency-ordered-before a load operation B (with std::memory_order_consume) if the result of load operation B is used in a further operation C in the same thread. It is important to note that operations B and C have to be in the same thread.

关于上述两种解释可参考下图

dependency-ordered-before需要应用在线程间，上图中A进行Store操作happens-before B进行的load操作，且B操作carries-a-dependency-to C操作，因此由于可传递性，A happens-before? C。

std::memory_order_consume代码示例

该代码均来自于《Concurrency in Action C++》相应章节。

注：std::memory_order_consume具有弱的同步和内存序限制，即不会像std::memory_order_release产生同步与关系。

具体可参考如下代码：


#include <atomic>
#include <cassert>
#include <string>
#include <thread>

struct X {
  int i_;
  std::string s_;
};

std::atomic<int> a;
std::atomic<X*> p;

void create_x() {
  X* x = new X;
  x->i_ = 42;
  x->s_ = "hello";
  a.store(99, std::memory_order_relaxed);
  p.store(x, std::memory_order_release);
}

void use_x() {
  X* x;
  while (!(x = p.load(std::memory_order_consume)));
  assert(x->i_ == 42);
  assert(x->s_ == "hello");
  assert(a.load(std::memory_order_relaxed) == 99);
  
}

int main() {
  std::thread t1(create_x);
  std::thread t2(use_x);
  t1.join();
  t2.join();
  return 0;
}

上述代码中，use_x中assert(a.load(std::memory_order_relaxed)==99) 可能触发断言。

原因为：

x通过std::memory_order_consume所得，由data dependency介绍部分知，操作p.store(x, std::memory_order_release)?dependency-ordered-before 语句while (!(x = p.load(std::memory_order_consume)))，而该语句又carries-a-dependency-to *x，因此针对use_x中前两个assert均不会失败。

由于std::memory_order_consume具有弱的同步关系，因此无法保证a的值为99，故触发断言。