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 [b],eax
d= b + 1;
011213F0 mov eax,dword ptr [b] <strong> </strong>
011213F3 add eax,1
011213F6 mov dword ptr [d],eax
加上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 [b],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写到内存,再重新从内存中进行读取(上面标红的汇编代码)。
那么我们接着看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