C++学习笔记：volatile的作用

1、volatile介绍

volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。用volatile关键字声明的变量i每一次被访问时，执行部件都会从i相应的内存单元中取出i的值。

没有用volatile关键字声明的变量i在被访问的时候可能直接从cpu的寄存器中取值（因为之前i被访问过，也就是说之前就从内存中取出i的值保存到某个寄存器中），之所以直接从寄存器中取值，而不去内存中取值，是因为编译器优化代码的结果（访问cpu寄存器比访问ram快的多）。

以上两种情况的区别在于被编译成汇编代码之后，两者是不一样的。之所以这样做是因为变量i可能会经常变化，保证对特殊地址的稳定访问。

volatile的三个特性：易变性、不可优化型和顺序性。

2、volatile的第一个特性：易变性

使用该关键字的例子如：int volatile nVint;

当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。 例如：

volatile int i=10;

　　 int a = i;

　　 ...

　　 //其他代码，并未明确告诉编译器，对i进行过操作

　　 int b = i;

volatile 指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。

注意，在VS中一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：

首先，用VS2010建一个win32 console工程，输入下面的代码：

#include <stdio.h>
void main( )
{
int i=10;
int a = i;
printf("i= %d\n",a);
//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道
__asm
{
mov dword ptr [ebp-4], 20h
}
int b = i;
printf("i= %d\n",b);
}

不加volatile关键字的时候，运行结果如下图所示（Debug模式）：

但是这个结果又与常理相悖，上面提过，debug版本是没有优化过的，理应能够得到正确的结果，但是。。。。。。我母鸡了。。。有知晓的，看出错误的，请留言告知。大谢大谢，发红包！



realease模式：

因为release版本会对代码进行优化，所以该结果是正常的。



在调试版本模式运行程序，输出结果如下：（异常，但是尚未知晓其原因？）

　 i = 10

　　 i = 10

然后，在release版本模式运行程序，输出结果如下：

　　 i = 10

　　 i = 10

输出的结果明显表明，难道是debug模式和release模式下，编译器对代码进行了优化，两次都没有输出正确的i值？？

我们把 i的声明加上volatile关键字，看看有什么变化。

代码：

#include <stdio.h>
void main( )
{
<span style="color:#CC0000;"><strong>volatile</strong></span> int i=10;
int a = i;
printf("i= %d\n",a);
//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道
__asm
{
mov dword ptr [ebp-4], 20h
}
int b = i;
printf("i= %d\n",b);
}

Debug版本：这个结果也很奇怪，常理说，加上volatile这个关键字之后，不论是debug版本还是realease版本都是能够得到正确结果的。


Realease版本：



所以，只有在release版本运行程序，输出才是正确结果：

　　 i = 10

　　 i = 32

但是，理论上不应该是debug版本在加上volatile关键字之后也是能够得到正确结果的？为何呢？？？

系统总是在 volatile 对象被请求的那一刻读取其当前值，即使上一条指令从同一对象请求值。而且，该对象的值在赋值时立即写入。

volatile 修饰符通常用于由多个线程访问而不使用 lock 语句来序列化访问的字段。使用 volatile 修饰符能够确保一个线程检索由另一线程写入的最新值。

3、从汇编代码看，volatile修饰的变量的变化（易变性）：

代码：

<strong>#include <stdio.h>
#include <iostream>
using namespace std;
void main( )
{
volatile int a = 5;//加与不加？
int b = 10;
int c = 20;
int d;
scanf("%d",&c);

a = c+1;

b = a + 1;

d= b + 1;
cout<< a << b << c << d;
}
</strong>

先看debug版本：

不加volatile关键字的汇编代码：

a = c+1;
011213DE  mov         eax,dword ptr [c]
011213E1  add         eax,1
011213E4  <strong><span style="color:#CC0000;">mov         dword ptr [a],eax  </span></strong>

b = a + 1;
011213E7  <strong><span style="color:#CC0000;">mov         eax,dword ptr [a]  </span></strong>
011213EA  add         eax,1
011213ED <strong> </strong>mov         dword ptr ,eax

d= b + 1;
011213F0  mov         eax,dword ptr [b] <strong> </strong>
011213F3  add         eax,1
011213F6  mov         dword ptr [d],eax

[b]加上volatile关键字之后的汇编代码：

a = c+1;
00E113DE  mov         eax,dword ptr [c]
00E113E1  add         eax,1
00E113E4 <span style="color:#CC0000;"> <strong>mov         dword ptr [a],eax  </strong></span>

b = a + 1;
00E113E7  <span style="color:#FF0000;"><strong>mov         eax,dword ptr [a]  </strong></span>
00E113EA  add         eax,1
00E113ED <strong> </strong><span style="color:#CC0000;"><span style="color:#000000;">mov         dword ptr ,eax  </span></span><strong><span style="color:#CC0000;">
</span></strong>
d= b + 1;
00E113F0  mov         eax,dword ptr [b]
00E113F3  add         eax,1
00E113F6  mov         dword ptr [d],eax

能够看出，debug版本下汇编代码确实是一样的，都是有将a写到内存，再重新从内存中进行读取（上面标红的汇编代码）。
[b]那么我们接着看release版本：

不加volatile关键字时，汇编代码;

a = c+1;
0114101B  mov         edx,dword ptr [c]
0114101E  lea         eax,[edx+1]

b = a + 1;
<span style="color:#CC0000;"><strong>01141021  lea         ecx,[eax+1]  </strong></span>
01141024  add         esp,8

d= b + 1;
01141027  <span style="color:#FF0000;">lea        </span><span style="color:#CC0000;"><span style="color:#FF0000;"><strong> esi,[ecx+1] </strong> </span>
<span style="color:#000000;">    cout<< a << b << c << d;</span>
</span>

b = a + 1;这条语句，对应的汇编指令是：lea ecx, [eax + 1]。由于变量a，在前一条语句a = c+1执行时，被缓存在了寄存器eax中，因此b = a + 1；语句，可以直接使用仍旧在寄存器eax中的a，来进行计算，对应的也就是汇编：[eax + 1]。

加上volatile关键字之后的汇编代码：

    a = c+1;
00AB1023  mov         ecx,dword ptr [c]  
00AB1026  inc         ecx  
00AB1027  <span style="color:#CC0000;"><strong>mov       dword ptr [a],ecx  </strong></span>

    b = a + 1;
00AB102A  <span style="color:#CC0000;"><strong>mov         eax,dword ptr [a] </strong></span> 

    d= b + 1;
    cout<< a << b << c << d;

唯一的不同之处，是变量a被设置为volatile属性，一个小小的变化，带来的是汇编代码上很大的变化。a = c+1执行后，寄存器ecx中的a，被写回内存：mov dword ptr [esp+0Ch], ecx。然后，在执行b = a + 1；语句时，变量a有重新被从内存中读取出来：mov eax, dword ptr [esp + 0Ch]，而不再直接使用寄存器ecx中的内容。

小结：

从以上的两个用例，就可以看出C/C++ Volatile关键词的第一个特性：易变性。所谓的易变性，在汇编层面反映出来，就是两条语句，下一条语句不会直接使用上一条语句对应的volatile变量的寄存器内容，而是重新从内存中读取。

4、volatile不可优化性的应用例子

下面这个例子就正常了，不加volatile关键时候，空循环是不执行的，但是在debug版本下会执行。因为realease版本会对代码进行优化，所以不执行。而加上关键字volatile之后，不管是debug版本还是realease版本都是会执行的。

#include <stdio.h>
void main( )
{
    for (int i=0; i<1000000000; i++); //这个语句用来测试空循环的速度的 ，但是编译器肯定要把它优化掉，根本就不执行。realease版本下不执行，而debug版本，会执行
    //for ( volatile int i=0; i<1000000000; i++); //它就会执行了,debug和realease版本是会执行的
}<strong>
</strong>

不加volatile关键字时：debug版本能够得到正确结果，release版本会进行优化

加上volatile关键字时：debug和release版本都是能够得到正确结果。

小结：

总结出C/C++ Volatile关键词的第二个特性：“不可优化”特性。volatile告诉编译器，不要对我这个变量进行各种激进的优化，甚至将变量直接消除，保证程序员写在代码中的指令，一定会被执行。相对于前面提到的第一个特性：”易变”性，”不可优化”特性可能知晓的人会相对少一些。

5、volatile的顺序性

Volatile经常为一个为多线程而生的关键词：一个全局变量，会被多线程同时访问/修改，那么线程内部，就不能假设此变量的不变性，并且基于此假设，来做一些程序设计。当然，这样的假设，本身并没有什么问题，多线程编程，并发访问/修改的全局变量，通常都会建议加上Volatile关键词修饰，来防止C/C++编译器进行不必要的优化。但是，很多时候，C/C++ Volatile关键词，在多线程环境下，会被赋予更多的功能，从而导致问题的出现。

这部分后续再更新吧。

参考：http://blog.chinaunix.net/uid-23860671-id-150546.html