基本解释
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/