zz剖析为什么在多核多线程程序中要慎用volatile关键字？

【摘要】编译器保证volatile自己的读写有序，但由于optimization和多线程可以和非volatile读写interleave，也就是不原子，也就是没有用。C++11 supposed会支持atomic operation。

---------------------------------------------^C^V的分割线---原帖在这里--------------------------------------------------------------

这篇文章详细剖析了为什么在多核时代进行多线程编程时需要慎用volatile关键字。

主要内容有：
1. C/C++中的volatile关键字
2. Visual Studio对C/C++中volatile关键字的扩展
3. Java/.NET中的volatile关键字
4. Memory Model（内存模型）
5. Volatile使用建议

1. C/C++中的volatile关键字
1.1 传统用途
C/C++作为系统级语言，它们与硬件的联系是很紧密的。volatile的意思是“易变的”，这个关键字最早就是为了针对那些“异常”的内存操作而准备的。它的效果是让编译器不要对这个变量的读写操作做任何优化，每次读的时候都直接去该变量的内存地址中去读，每次写的时候都直接写到该变量的内存地址中去，即不做任何缓存优化。它经常用在需要处理中断的嵌入式系统中，其典型的应用有下面几种：

a. 避免用通用寄存器对内存读写的优化。编译器常做的一种优化就是：把常用变量的频繁读写弄到通用寄存器中，最后不用的时候再存回内存中。但是如果某个内存地址中的值是由片外决定的（例如另一个线程或是另一个设备可能更改它），那就需要volatile关键字了。（感谢Kenny老师指正）
b. 硬件寄存器可能被其他设备改变的情况。例如一个嵌入式板子上的某个寄存器直接与一个测试仪器连在一起，这样在这个寄存器的值随时可能被那个测试仪器更改。在这种情况下如果把该值设为volatile属性的，那么编译器就会每次都直接从内存中去取这个值的最新值，而不是自作聪明的把这个值保留在缓存中而导致读不到最新的那个被其他设备写入的新值。
c. 同一个物理内存地址M有两个不同的内存地址的情况。例如两个程序同时对同一个物理地址进行读写，那么编译器就不能假设这个地址只会有一个程序访问而做缓存优化，所以程序员在这种情况下也需要把它定义为volatile的。

1.2 多线程程序中的错误用法
看到这里，很多朋友自然会想到：恩，那么如果是两个线程需要同时访问一个共享变量，为了让其中两个线程每次都能读到这个变量的最新值，我们就把它定义为volatile的就好了嘛！我想这个就是多线程程序中volatile之所以引起那么多争议的最大原因。可惜的是，这个想法是错误的。

举例来说，想用volatile变量来做同步（例如一个flag）？错！为什么？很简单，虽然volatile意味着每次读和写都是直接去内存地址中去操作，但是volatile在C/C++现有标准中即不能保证原子性（Atomicity）也不能保证顺序性（Ordering），所以几乎所有试图用volatile来进行多线程同步的方案都是错的。我之前一篇文章介绍了Sequential Consistency模型（后面简称SC），它其实就是我们印象中多线程程序应该有的执行顺序。但是，SC最大的问题是性能太低了，因为CPU/编译器完全没有必要严格按代码规定的顺序（program order）来执行每一条指令。学过体系结构的同学应该知道不管是编译器也好CPU也好，他们最擅长做的事情就是帮你做乱序优化。在串行时代这些乱序优化对程序员来说都是透明的，封装好了的，你不用关心它们到底给你乱序成啥样了，因为它们会保证优化后的程序的运行结果跟你写程序时预期的结果是一模一样的。但是进入多核时代之后，CPU和编译器还会继续做那些串行时代的优化，更重要的是这些优化还会打破你多线程程序的SC模型语义，从而使得多线程程序的实际运行结果与我们所期待的运行结果不一致！

拿X86来说，它的多核内存模型没有严格执行SC，即属于weak ordering（或者叫relax ordering？）。它唯一允许的乱序优化是可以把对不同地址的load操作提到store之前去（即把store x->load y乱序优化成load y -> store x）。而store x -> store y、load x -> load y，以及load y -> store x不允许交换执行顺序。在X86这样的内存模型下，volatile关键字根本就不能保证对不同volatile变量x和y的store x -> load y的操作不会被CPU乱序优化成load y -> store x。

而对多线程读写操作的原子性来说，诸如volatile x=1这样的写操作的原子性其实是由X86硬件保证的，跟volatile没有任何关系。事实上，volatile根本不能保证对没有内存对齐的变量（或者超出机器字长的变量）的读写操作的原子性。

为了有个更直观的理解，我们来看看CPU的乱序优化是如何让volatile在多线程程序中显得如此无力的。下面这个著名的Dekker算法是想用flag1/2和turn来实现两个线程情况下的临界区互斥访问。这个算法关键就在于对flag1/2和turn的读操作（load）是在其写操作（store）之后的，因此这个多线程算法能保证dekker1和dekker2中对gSharedCounter++的操作是互斥的，即等于是把gSharedCounter++放到临界区里去了。但是，多核X86可能会对这个store->load操作做乱序优化，例如dekker1中对flag2的读操作可能会被提到对flag1和turn的写操作之前，这样就会最终导致临界区的互斥访问失效，而gSharedCounter++也会因此产生data race从而出现错误的计算结果。那么为什么多核CPU会对多线程程序做这样的乱序优化呢？因为从单线程的视角来看flag2和flag1、turn是没有依赖关系的，所以CPU当然可以对他们进行乱序优化以便充分利用好CPU里面的流水线（想了解更多细节请参考计算机体系结构相关书籍）。这样的优化虽然从单线程角度来讲没有错，但是它却违反了我们设计这个多线程算法时所期望的那个多线程语义。（想要解决这个bug就需要自己手动添加memory barrier，或者干脆别去实现这样的算法，而是使用类似pthread_mutex_lock这样的库函数，后面我会再讲到这点）

当然，对不同的CPU来说他们的内存模型是不同的。比如说，如果这个程序是在单核上以多线程的方式执行那么它肯定不会出错，因为单核CPU的内存模型是符合SC的。而在例如PowerPC，ARM之类的架构上运行结果到底如何就得去翻它们的硬件手册中内存模型是怎么定义的了。

/*
 * Dekker's algorithm, implemented on pthreads
 *
 * To use as a test to see if/when we can make
 * memory consistency play games with us in
 * practice.
 *
 * Compile: gcc -O2 -o dekker dekker.c -lpthread
 * Source: http://jakob.engbloms.se/archives/65
 */

#include <assert.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#undef PRINT_PROGRESS

static volatile int flag1 = 0;
static volatile int flag2 = 0;
static volatile int turn  = 1;
static volatile int gSharedCounter = 0;
int gLoopCount;
int gOnePercent;

void dekker1( ) {
        flag1 = 1;
        turn  = 2;
        while((flag2 ==  1) && (turn == 2)) ;
        // Critical section
        gSharedCounter++;
        // Let the other task run
        flag1 = 0;
}

void dekker2(void) {
        flag2 = 1;
        turn = 1;
        while((flag1 ==  1) && (turn == 1)) ;
        // critical section
        gSharedCounter++;       
        // leave critical section
        flag2 = 0;
}

//
// Tasks, as a level of indirection
//
void *task1(void *arg) {
        int i,j;
        printf("Starting task1\n");
        // Do the dekker very many times
#ifdef PRINT_PROGRESS
 for(i=0;i<100;i++) {
   printf("[One] at %d%%\n",i);
   for(j=gOnePercent;j>0;j--) {
     dekker1();
   }
 }
#else
 // Simple basic loop
        for(i=gLoopCount;i>0;i--) {
                dekker1();
        }
#endif

}

void *task2(void *arg) {
        int i,j;
        printf("Starting task2\n");
#ifdef PRINT_PROGRESS
 for(i=0;i<100;i++) {
   printf("[Two] at %d%%\n",i);
   for(j=gOnePercent;j>0;j--) {
     dekker2();
   }
 }
#else
        for(i=gLoopCount;i>0;i--) {
                dekker2();
        }
#endif
}

int
main(int argc, char ** argv)
{
        int            loopCount = 0;
        pthread_t      dekker_thread_1;
        pthread_t      dekker_thread_2;
        void           * returnCode;
        int            result;
        int            expected_sum;

/* Check arguments to program*/
        if(argc != 2)
        {
                fprintf(stderr, "USAGE: %s <loopcount>\n", argv[0]);
                exit(1);
        }

/* Parse argument */
        loopCount   = atoi(argv[1]); /* Don't bother with format checking */
        gLoopCount  = loopCount;
 gOnePercent = loopCount/100;
        expected_sum = 2*loopCount;
       
        /* Start the threads */
        result = pthread_create(&dekker_thread_1, NULL, task1, NULL);
        result = pthread_create(&dekker_thread_2, NULL, task2, NULL);

/* Wait for the threads to end */
        result = pthread_join(dekker_thread_1,&returnCode);
        result = pthread_join(dekker_thread_2,&returnCode);
        printf("Both threads terminated\n");

/* Check result */
        if( gSharedCounter != expected_sum ) {
                printf("[-] Dekker did not work, sum %d rather than %d.\n", gSharedCounter, expected_sum);
                printf("    %d missed updates due to memory consistency races.\n", (expected_sum-gSharedCounter));
                return 1;
        } else {
                printf("[+] Dekker worked.\n");
                return 0;
        }
}

2. Visual Studio对C/C++中volatile关键字的扩展
虽然C/C++中的volatile关键字没有对ordering做任何保证，但是微软从Visual Studio 2005开始就对volatile关键字添加了同步语义（保证ordering），即：对volatile变量的读操作具有acquire语义，对volatile变量的写操作具有release语义。Acquire和Release语义是来自data-race-free模型的概念。为了理解这个acquire语义和release语义有什么作用，我们来看看MSDN中的一个例子。

// volatile.cpp
// compile with: /EHsc /O2
// Output: Critical Data = 1 Success
#include <iostream>
#include <windows.h>
using namespace std;

volatile bool Sentinel = true;
int CriticalData = 0;

unsigned ThreadFunc1( void* pArguments ) {
   while (Sentinel)
      Sleep(0);   // volatile spin lock

// CriticalData load guaranteed after every load of Sentinel
   cout << "Critical Data = " << CriticalData << endl;
   return 0;
}

unsigned  ThreadFunc2( void* pArguments ) {
   Sleep(2000);
   CriticalData++;   // guaranteed to occur before write to Sentinel
   Sentinel = false; // exit critical section
   return 0;
}

int main() {
   HANDLE hThread1, hThread2;
   DWORD retCode;

hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&ThreadFunc1,
      NULL, 0, NULL);
   hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&ThreadFunc2,
      NULL, 0, NULL);

if (hThread1 == NULL || hThread2 == NULL)       {
      cout << "CreateThread failed." << endl;
      return 1;
   }

retCode = WaitForSingleObject(hThread1,3000);

CloseHandle(hThread1);
   CloseHandle(hThread2);

if (retCode == WAIT_OBJECT_0 && CriticalData == 1 )
      cout << "Success" << endl;
   else
      cout << "Failure" << endl;
}
例子中的 while (Sentinel) Sleep(0); // volatile spin lock 是对volatile变量的读操作，它具有acquire语义，acquire语义的隐义是当前线程在对sentinel的这个读操作之后的所有的对全局变量的访问都必须在该操作之后执行；同理，例子中的Sentinel = false; // exit critical section 是对volatile变量的写操作，它具有release语义，release语义的隐义是当前线程在对sentinel这个写操作之前的所有对全局变量的访问都必须在该操作之前执行完毕。所以ThreadFunc1（）读CriticalData时必定已经在ThreadFunc2（）执行完CriticalData++之后，即CriticalData最后输出的值必定为1。建议大家用纸画一下acquire/release来加深理解。一个比较形象的解释就是把acquire当成lock，把release当成unlock，它俩组成了一个临界区，所有临界区外面的操作都只能往这个里面移，但是临界区里面的操作都不能往外移，简单吧？

其实这个程序就相当于用volatile变量的acquire和release语义实现了一个临界区，在临界区内部的代码就是 Sleep(2000); CriticalData++; 或者更贴切点也可以看成是一对pthread_cond_wait和pthread_cond_signal。

这个volatile的acquire和release语义是VS自己的扩展，C/C++标准里是没有的，所以同样的代码用gcc编译执行结果就可能是错的，因为编译器/CPU可能做违反正确性的乱序优化。Acquire和release语义本质上就是为了保证程序执行时memory order的正确性。但是，虽然这个VS扩展使得volatile变量能保证ordering，它还是不能保证对volatile变量读写的原子性。事实上，如果我们的程序是跑在X86上面的话，内存对齐了的变量的读写的原子性是由硬件保证的，跟volatile没有任何关系。而像volatile g_nCnt++这样的语句本身就不是原子操作，想要保证这个操作是原子的，就必须使用带LOCK语义的++操作，具体请看我这篇文章。

另外，VS生成的volatile变量的汇编代码是否真的调用了memory barrier也得看具体的硬件平台，例如x86上就不需要使用memory barrier也能保证acquire和release语义，因为X86硬件本身就有比较强的memory模型了，但是Itanium上面VS就会生成带memory barrier的汇编代码。具体可以参考这篇。

但是，虽然VS对volatile关键字加入了acquire/release语义，有一种情况还是会出错，即我们之前看到的dekker算法的例子。这个其实蛮好理解的，因为读操作的acquire语义不允许在其之后的操作往前移，但是允许在其之前的操作往后移；同理，写操作的release语义允许在其之后的操作往前移，但是不允许在其之前的操作往后移；这样的话对一个volatile变量的读操作（acquire）当然可以放到对另一个volatile变量的写操作（release）之前了！Bug就是这样产生的！下面这个程序大家拿Visual Studio跑一下就会发现bug了（我试了VS2008和VS2010，都有这个bug）。多线程编程复杂吧？希望大家还没被弄晕，要是晕了的话也很正常，仔仔细细重新再看一遍吧:)

想解决这个Bug也很简单，直接在dekker1和dekker2中对flag1/flag2/turn赋值操作之后都分别加入full memory barrier就可以了，即保证load一定是在store之后执行即可。具体的我就不详述了。

#include <iostream>
#include <windows.h>
using namespace std;

static volatile int flag1 = 0;
static volatile int flag2 = 0;
static volatile int turn = 1; // must have "turn", otherwise the two threads might introduce deadlock at line 13&23 of "while..."
static int gCount = 0;

void dekker1() {
 flag1 = 1;
 turn = 2;
 while ((flag2 == 1) && (turn == 2));
 // critical section
 gCount++;
 flag1 = 0;  // leave critical section
}

void dekker2() {
 flag2 = 1;
 turn = 1;
 while ((flag1 == 1) && (turn == 1));
 // critical setion
 gCount++;
 flag2 = 0;  // leave critical section
}

unsigned ThreadFunc1( void* pArguments ) {
 int i;
 //cout << "Starting Thread 1" << endl;
 for (i=0;i<1000000;i++) {
  dekker1();
 }
 return 0;
}

unsigned  ThreadFunc2( void* pArguments ) {
 int i;
 //cout << "Starting Thread 2" << endl;
 for (i=0;i<1000000;i++) {
  dekker2();
 }
 return 0;
}

int main() {
 HANDLE hThread1, hThread2;
 //DWORD retCode;

hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&ThreadFunc1,
  NULL, 0, NULL);
 hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&ThreadFunc2,
  NULL, 0, NULL);

if (hThread1 == NULL || hThread2 == NULL) {
  cout << "CreateThread failed." << endl;
  return 1;
 }

WaitForSingleObject(hThread1,INFINITE);
 WaitForSingleObject(hThread2,INFINITE);
 cout << gCount << endl;

if (gCount == 2000000)
  cout << "Success" << endl;
 else
  cout << "Fail" << endl;
}
3. Java/.NET中的volatile关键字
3.1 多线程语义
Java和.NET分别有JVM和CLR这样的虚拟机，保证多线程的语义就容易多了。说简单点，Java和.NET中的volatile关键字也是限制虚拟机做优化，都具有acquire和release语义，而且由虚拟机直接保证了对volatile变量读写操作的原子性。 （volatile只保证可见性，不保证原子性。java中，对volatile修饰的long和double的读写就不是原子的 (http://java.sun.com/docs/books/jvms/second_edition/html /Threads.doc.html#22244)，除此之外的基本类型和引用类型都是原子的。– 多谢liuchangit指正） 这里需要注意的一点是，Java和.NET里面的volatile没有对应于我们最开始提到的C/C++中对“异常操作”用volatile修饰的传统用法。原因很简单，Java和.NET的虚拟机对安全性的要求比C/C++高多了，它们才不允许不安全的“异常”访问存在呢。

而且像JVM/.NET这样的程序可移植性都非常好。虽然现在C++1x正在把多线程模型添加到标准中去，但是因为C++本身的性质导致它的硬件平台依赖性很高，可移植性不是特别好，所以在移植C/C++多线程程序时理解硬件平台的内存模型是非常重要的一件事情，它直接决定你这个程序是否会正确执行。

至于Java和.NET中是否也存在类似VS 2005那样的bug我没时间去测试，道理其实是相同的，真有需要的同学自己应该能测出来。好像这篇InfoQ的文章中显示Java运行这个dekker算法没有问题，因为JVM给它添加了mfence。另一个臭名昭著的例子就应该是Double-Checked Locking了。

3.2 volatile int与AtomicInteger区别
Java和.NET中这两者还是有些区别的，主要就是后者提供了类似incrementAndGet()这样的方法可以直接调用（保证了原子性），而如果是volatile x进行++操作则不是原子的。increaseAndGet()的实现调用了类似CAS这样的原子指令，所以能保证原子性，同时又不会像使用synchronized关键字一样损失很多性能，用来做全局计数器非常合适。

4. Memory Model（内存模型）
说了这么多，还是顺带介绍一下Memory Model吧。就像前面说的，CPU硬件有它自己的内存模型，不同的编程语言也有它自己的内存模型。如果用一句话来介绍什么是内存模型，我会说它就是程序员，编程语言和硬件之间的一个契约，它保证了共享的内存地址里的值在需要的时候是可见的。下次我会专门详细写一篇关于它的内容。它最大的作用是取得可编程性与性能优化之间的一个平衡。

5. volatile使用建议
总的来说，volatile关键字有两种用途：一个是ISO C/C++中用来处理“异常”内存行为（此用途只保证不让编译器做任何优化，对多核CPU是否会进行乱序优化没有任何约束力），另一种是在Java/.NET（包括Visual Studio添加的扩展）中用来实现高性能并行算法（此种用途通过使用memory barrier保证了CPU/编译器的ordering，以及通过JVM或者CLR保证了对该volatile变量读写操作的原子性）。

一句话，volatile对多线程编程是非常危险的，使用的时候千万要小心你的代码在多核上到底是不是按你所想的方式执行的，特别是对现在暂时还没有引入内存模型的C/C++程序更是如此。安全起见，大家还是用Pthreads，Java.util.concurrent，TBB等并行库提供的lock/spinlock，conditional variable, barrier, Atomic Variable之类的同步方法来干活的好，因为它们的内部实现都调用了相应的memory barrier来保证memory ordering，你只要保证你的多线程程序没有data race，那么它们就能帮你保证你的程序是正确的（是的，Pthreads库也是有它自己的内存模型的，只不过它的内存模型还些缺点，所以把多线程内存模型直接集成到C/C++中是更好的办法，也是将来的趋势，但是C++1x中将不会像Java/.NET一样给volatile关键字添加acquire和release语义，而是转而提供另一种具有同步语义的atomic variables，此为后话）。如果你想实现更高性能的lock free算法，或是使用volatile来进行同步，那么你就需要先把CPU和编程语言的memory model搞清楚，然后再时刻注意Atomicity和Ordering是否被保证了。（注意，用没有acquire/release语义的volatile变量来进行同步是错误的，但是你仍然可以在C/C++中用volatile来修饰一个不是用来做同步（例如一个event flag）而只是被不同线程读写的共享变量，只不过它的新值什么时候能被另一个线程读到是没有保证的，需要你自己做相应的处理）

Herb Sutter 在他的那篇volatile vs. volatile中对这两种用法做了很仔细的区分，我把其中两张表格链接贴过来供大家参考：

volatile的两种用途
volatile两种用途的异同

最后附上《Java Concurrency in Practice》3.1.4节中对Java语言的volatile关键字的使用建议（不要被英语吓到，这些内容确实对你有用，而且还能顺便帮练练英语，哈哈）：

So from a memory visibility perspective, writing a volatile variable is like exiting a synchronized block and reading a volatile variable is like entering a synchronized block. However, we do not recommend relying too heavily on volatile variables for visibility; code that relies on volatile variables for visibility of arbitrary state is more fragile and harder to understand than code that uses locking.

Use volatile variables only when they simplify implementing and verifying your synchronization policy; avoid using volatile variables when veryfing correctness would require subtle reasoning about visibility. Good uses of volatile variables include ensuring the visibility of their own state, that of the object they refer to, or indicating that an important lifecycle event (such as initialization or shutdown) has occurred.

Locking can guarantee both visibility and atomicity; volatile variables can only guarantee visibility.

You can use volatile variables only when all the following criteria are met:
(1) Writes to the variable do not depend on its current value, or you can ensure that only a single thread ever updates the value;
(2) The variable does not participate in invariants with other state variables; and
(3) Locking is not required for any other reason while the variable is being accessed.

参考资料
1. 《Java Concurrency in Practice》3.1.4节
2. volatile vs. volatile（Herb Sutter对volatile的阐述，必看）
3. The “Double-Checked Locking is Broken” Declaration
4. Threading in C#
5. Volatile: Almost Useless for Multi-Threaded Programming
6. Memory Ordering in Modern Microprocessors
7. Memory Ordering @ Wikipedia
8. 内存屏障什么的
9. The memory model of x86
10. VC 下 volatile 变量能否建立 Memory Barrier 或并发锁
11. Sayonara volatile（Concurrent Programming on Windows作者的文章 跟我观点几乎一致）
12. Java 理论与实践: 正确使用 Volatile 变量
13. Java中的Volatile关键字