基本解释

    C++11引入了多线程，同时也引入了一套内存模型。从而提供了比较完善的一套多线程体系。在单线程时代，一切都很简单。没有共享数据，没有乱序执行，所有的指令的执行都是按照预定的时间线。但是也正是因为这个强的同步关系，给CPU提供的优化程度也就相对低了很多。无法体现当今多核CPU的性能。因此需要弱化这个强的同步关系，来增加CPU的性能优化。

    C++11提供了6种内存模型：

  1 enum memory_order{
  2   memory_order_relaxed,
  3   memory_order_consume,
  4   memory_order_acquire,
  5   memory_order_release,
  6   memory_order_acq_rel,
  7   memory_order_seq_cst
  8 }

      原子类型的操作可以指定上述6种模型的中的一种，用来控制同步以及对执行序列的约束。从而也引起两个重要的问题：

1.哪些原子类型操作需要使用内存模型？
2.内存模型定义了那些同步语义（synchronization ）和执行序列约束（ordering constraints）？

原子操作可分为3大类：

读操作：memory_order_acquire, memory_order_consume
写操作：memory_order_release
读-修改-写操作：memory_order_acq_rel, memory_order_seq_cst

未被列入分类的memory_order_relaxed没有定义任何同步语义和顺序一致性约束

执行序列约束

    C++11中有3种不同类型的同步语义和执行序列约束：

1. 顺序一致性（Sequential consistency）：对应的内存模型是memory_order_seq_cst

2.请求-释放（Acquire-release）：对应的内存模型是memory_order_consume，memory_order_acquire，memory_order_release，memory_order_acq_rel

3.松散型（非严格约束。Relaxed）：对应的内存模型是memory_order_relaxed

下面对上述3种约束做一个大概解释：

Sequential consistency：指明的是在线程间，建立一个全局的执行序列

Acquire-release：在线程间的同一个原子变量的读和写操作上建立一个执行序列

Relaxed：只保证在同一个线程内，同一个原子变量的操作的执行序列不会被重排序（reorder），这种保证也称之为modification order consistency，但是其他线程看到的这些操作的执行序列式不同的。

还有一种consume模式，也就是std::memory_order_consume。这个模式主要是引入了原子变量的数据依赖。

代码解释

Sequential consistency

Sequential consistency有两个特性：
1.所有线程执行指令的顺序都是按照源代码的顺序；
2.每个线程所能看到其他线程的操作的执行顺序都是一样的。

示例代码：

  1 std::string work;
  2 std::atomic<bool> ready(false);
  3 
  4 void consumer(){
  5   while(!ready.load()){}
  6   std::cout<< work << std::endl;
  7 }
  8 
  9 void producer(){
 10   work= "done";
 11   ready=true;
 12 }

1. work = "done"  sequenced-before ready=true 推导出 work = "done" happens-before ready=true
2. while(!ready.load()){} sequenced-before std::cout<< work << std::endl 推导出 while(!ready.load()){} happens-before std::cout<< work << std::endl
3. ready = true synchronizes-with while(!ready.load()){} 推导出 ready = true inter-thread happens-before while (!ready.load()){}，也就推导出ready = true happens-before while (!ready.load()){}

同时因为happens-before关系具有传递性，所以上述代码的执行序列式：       

work = "done" happens-before ready = true happens-before while(!ready.load()){} happens-before std::cout<< work << std::endl

Acquire-release

关键思想是：在同一个原子变量的release操作和acquire操作间同步，同时也就建立起了执行序列约束。

所有的读和写动作不能移动到acquire操作之前。
所有的读和写动作不能移动到release操作之后。

release-acquire操作在线程间建立了一种happens-before。所以acquire之后的操作和release之前的操作就能进行同步。同时，release-acquire操作具有传递性。

示例代码：

  1 std::vector<int> mySharedWork;
  2 std::atomic<bool> dataProduced(false);
  3 std::atomic<bool> dataConsumed(false);
  4 
  5 void dataProducer(){
  6     mySharedWork={1,0,3};
  7     dataProduced.store(true, std::memory_order_release);
  8 }
  9 
 10 void deliveryBoy(){
 11     while( !dataProduced.load(std::memory_order_acquire) );
 12     dataConsumed.store(true,std::memory_order_release);
 13 }
 14 
 15 void dataConsumer(){
 16     while( !dataConsumed.load(std::memory_order_acquire) );
 17     mySharedWork[1]= 2;
 18 }

1. mySharedWork={1,0,3};  is sequenced-before dataProduced.store(true, std::memory_order_release);
2. while( !dataProduced.load(std::memory_order_acquire) ); is sequenced-before dataConsumed.store(true,std::memory_order_release);
3. while( !dataConsumed.load(std::memory_order_acquire) ); is sequenced-before mySharedWork[1]= 2;

4. dataProduced.store(true, std::memory_order_release); is synchronizes-with while( !dataProduced.load(std::memory_order_acquire) );
5. dataConsumed.store(true,std::memory_order_release); is synchronizes-with while( !dataConsumed.load(std::memory_order_acquire) );

因此dataProducer和dataConsumer能够正确同步。

原子变量的数据依赖

std::memory_order_consume说的是关于原子变量的数据依赖。
数据依赖有两种方式：
1. carries-a-dependency-to：如果操作A的结果用于操作B的操作当中，那么A carries-a-dependency-to（将依赖带入） B
2. dependency-ordered-before：如果操作B的结果进一步在相同的线程内被操作C使用，那么A的stor操作(with std::memory_order_release, std::memory_order_acq_rel or std::memory_order_seq_cst)是dependency-ordered-before（在依赖执行序列X之前）B的load操作(with std::memory_order_consume)。

示例代码：

  1 std::atomic<std::string*> ptr;
  2 int data;
  3 std::atomic<int> atoData;
  4 
  5 void producer(){
  6     std::string* p  = new std::string("C++11");
  7     data = 2011;
  8     atoData.store(2014,std::memory_order_relaxed);
  9     ptr.store(p, std::memory_order_release);
 10 }
 11 
 12 void consumer(){
 13     std::string* p2;
 14     while (!(p2 = ptr.load(std::memory_order_consume)));
 15     std::cout << "*p2: " << *p2 << std::endl;
 16     std::cout << "data: " << data << std::endl;
 17     std::cout << "atoData: " << atoData.load(std::memory_order_relaxed) << std::endl;
 18 }

1. ptr.store(p, std::memory_order_release) is dependency-ordered-before while (!(p2 = ptr.load(std::memory_order_consume)))。因为后面的std::cout << "*p2: " << *p2 << std::endl;将读取load操作的结果。
2. while (!(p2 = ptr.load(std::memory_order_consume)) carries-a-dependency-to std::cout << "*p2: " << *p2 << std::endl。因为*p2的输出使用了ptr.load操作的结果

综上所述，对于data和atoData的输出是没有保证的。因为它们和ptr.load操作没有carries-a-dependency-to关系。同时它们又不是原子变量，这将会导致race condition。因为在同一时间，多个线程可以访问data，线程t1（producer）同时会修改它。程序的行为因此是未定义的（undefined）。

参考：

http://en.cppreference.com/w/cpp/atomic/memory_order
http://www.modernescpp.com/