本文简单介绍volatile关键字的使用，进而引出编译期间内存乱序的问题，并介绍了有效防止编译器内存乱序所带来的问题的解决方法，文中简单提了下CPU指令乱序的现象，但并没有深入讨论。

以下是我搭建的博客地址： http://itblogs.ga/blog/20150329150706/    欢迎到这里阅读文章。

volatile关键字

volatile关键字用来修饰一个变量，提示编译器这个变量的值随时会改变。通常会在多线程、信号处理、中断处理、读取硬件寄存器等场合使用。

程序在执行时，通常将数据（变量的值）从内存的读到寄存器中，然后进行运算，此后对该变量的处理，都是直接访问寄存器就可以了，不再访问内存，因为 访存的代价是很高的（这块是访问寄存器还是重新访存加载到寄存器是编译器在编译阶段就决定了的）。但在上述说的几种情况下，内存会被另一个线程或者信号处 理函数、中断处理函数、硬件改掉，这样，代码只访问寄存器的话，永远得不到真实的值。

对这样的变量（会在多线程、线程与信号、线程与中断处理*同访问的，或者硬件寄存器），在定义时都会加上volatile关键字修饰。这样编译器 在编译时，编译出的指令会重新访存，这样就能保证拿到正确的数据了。但这里需要注意的是，编译器只能做到让指令重新访问内存，而不是直接使用寄存器中的 值，这些和缓存没有关系，具体执行时指令是访问内存还是访问的缓存，编译器也无法干预。

另外，除了使用寄存器来避免多次访存外，编译器有时可能直接将变量全部优化掉，使用常数代替。比如：

int main()
{
    int a = 1;
    int b = 2;

printf("a = %d, b = %d \n", a, b);
}

编译器可能直接优化为：

int main()
{
    printf("a = %d, b = %d \n", 1, 2);
}

如果对ab的声明加了 volatile关键字，编译器将不在做这样的优化。

还有，对所有volatile变量，编译器在编译阶段保证不会将访问volatile变量的指令进行乱序重排。

指令乱序

那么什么是指令乱序，指令乱序是为了提高性能，而导致的执行时的指令顺序和代码写的顺序不一致。指令乱序有编译期间指令乱序和执行时指令乱序。

执行时指令乱序是CPU的一个特性，这块比较复杂，不再这里提及。我们只需要知道在x86/x64的体系架构下，程序员一般不需要关注执行时指令乱序（不需要关注不代表没有）。

编译期间指令乱序是指在编译成二进制代码时，编译器为了所谓的优化进行了指令重排，导致二进制指令的顺序和我们写的代码的顺序是不一致的。

比如以下代码：

int a;
int b;

int main()
{
    a = b + 1;
    b = 0;
}

会被优化成（实际上在汇编阶段进行的乱序优化，优化后的代码也只能以汇编的方式查看，这里只是拿C代码举例说明一下）：

int a;
int b;

int main()
{
    b = 0;
    a = b + 1;
}

对加上volatile关键字的变量的访问，编译器不会进行指令乱序的优化，保证volatile变量的访问顺序和代码写的是一样的。比如如下代码不会优化：

volatile int a;
volatile int b;

int main()
{
    a = b + 1;
    b = 0;
}

但是以下代码，依然会乱序，因为编译器只是保证volatile变量访问的顺序，对于非volatile变量之间，以及volatile以及非volatile变量之间的顺序，编译器还是会优化。

int a;
volatile int b;

int main()
{
    a = b + 1;
    b = 0;
}

asm volatile ("" : : : "memory");

一般编程时如果使用到volatile关键字，那么基本上都需要考虑编译器指令乱序的问题。解决编译器指令乱序所带来的问题，除了上面将必要的变量声明为volatile，还可以使用下面一条嵌入式汇编语句：

这是一条空汇编语句，只是告诉编译器，内存发生了变化。编译器遇到这条语句后，会生成访存更新寄存器的指令，将所有的寄存器的值更新一遍。这里是编译器遇到这条语句额外生成了一些代码，而不是CPU遇到这条语句执行了一些处理，因为这条语句本身并没有CPU指令与之对应。

由于编译器知道这条语句之后内存发生了变化，编译器在编译时就会保证这条语句上下的指令不会乱，即这条语句上面的指令，不会乱序到语句下面，语句下面的指令不会乱序到语句上面。

利用编译器这个功能，程序员可以：

1、利用这条语句，强制程序访存，而不是使用寄存器中的值，作为使用volatile关键字的一个替代手段；

2、在不允许乱序的两个语句之间插入这条语句从而保证不会被编译器乱序。

下面看一个应用的例子，两个线程访问共享的全局变量：

#define ARRAY_LEN 12

volatile int flag = 0;
int a[ARRAY_LEN];

pthread1()
{
    a[ARRAY_LEN - 1] = 10; <br>    asm volatile ("" : : : "memory");
    flag = 1;
}

pthread2()
{
    int sum = 0;

if(flag == 0) {
        sum += a[ARRAY_LEN - 1];
    }    
}线程2假定flag==1时，线程1已经将数据放到数组中了。但实际上，如果没有  asm volatile ("" : : : "memory")，线程1并不能保证flag = 1在数组赋值之后。原因就是我们前面提到的编译器指令乱序。

指令乱序是一个比较复杂的话题，我们这里只考虑了编译器指令乱序，在intel架构的CPU上，基本上考虑到这些就足够了。但在弱指令序的CPU上，比如mips，了解这些还远远不够。本文不打算展开CPU指令乱序的话题，感兴趣的可以参考以下文章了解以下：

volatile关键字的使用

volatile关键字使用和const一致，下面是一个总结：

char const * pContent;       // *pContent是const,   pContent可变
(char *) const pContent;     //  pContent是const,  *pContent可变
char* const pContent;        //  pContent是const,  *pContent可变
char const* const pContent;  //  pContent 和       *pContent都是const

沿着*号划一条线，如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。

参考资料

Memory Ordering at Compile Time

以下是我搭建的博客地址：
原文链接：http://itblogs.ga/blog/20150329150706/ 转载请注明出处