C++11内存模型的粗略解释
基本解释
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/