volatile的作用

时间：2010-05-16 来源：ddnnetddn

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
    1). 并行设备的硬件寄存器（如：状态寄存器）
    2). 一个中断服务子程序中会访问到的非自动变量(Non- automatic variables)
    3). 多线程应用中被几个任务共享的变量
    回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求 volatile变量。不懂得volatile内容将会带来灾难。
    假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
    1). 一个参数既可以是const还可以是volatile 吗？解释为什么。
    2). 一个指针可以是volatile 吗？解释为什么。
    3). 下面的函数有什么错误：
         int square(volatile int *ptr)
         {
              return *ptr * *ptr;
         }
    下面是答案：
    1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
    2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
    3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
    int square(volatile int *ptr)
    {
         int a,b;
         a = *ptr;
         b = *ptr;
         return a * b;
     }
    由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
     long square(volatile int *ptr)
     {
            int a;
            a = *ptr;
            return a * a;
     }

讲讲我的理解：（欢迎打板子...~~！）

关键在于两个地方：

1. 编译器的优化  (请高手帮我看看下面的理解)

在本次线程内, 当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后，再取变量值时，就直接从寄存器中取值；

当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致

当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致

当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致

举一个不太准确的例子：

发薪资时，会计每次都把员工叫来登记他们的银行卡号；一次会计为了省事，没有即时登记，用了以前登记的银行卡号；刚好一个员工的银行卡丢了，已挂失该银行卡号；从而造成该员工领不到工资

员工－－原始变量地址
银行卡号－－原始变量在寄存器的备份

2. 在什么情况下会出现(如1楼所说)

    1). 并行设备的硬件寄存器（如：状态寄存器）
    2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
    3). 多线程应用中被几个任务共享的变量


补充： volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人；

“易变”是因为外在因素引起的，象多线程，中断等，并不是因为用volatile修饰了的变量就是“易变”了，假如没有外因，即使用volatile定义，它也不会变化；

而用volatile定义之后，其实这个变量就不会因外因而变化了，可以放心使用了；大家看看前面那种解释（易变的）是不是在误导人

这里还有一个例子，以帮助我们理解volatile

>>>问题:
在/kernel/sched.c中有一句：
...
(*(unsigned long *)&jiffies)++
这么理解妥否：取jiffies地址，强行转换为unsigned long型的指针，此地址指向的目标变量进行++操作。
为何要这样绕圈子，不就是jiffies++操作吗？

>>> 回应:
by 硅谷农民 on Friday June 07 2002 @ 02:08PM EDT

有网友问为什么在 do_timer()函数中，有一句(*(unsigned long *)&jiffies)++，为什么
不直接用 jiffies++呢？
这个问题和两个原因有关：
* jiffiers是volatile变量
* CPU可能会重新排序指令

我编了3个小程序来测试，

jiffier1.c

int main()
{
unsigned long jiffiers = 777;

jiffiers++;

return 0;
}

gcc -S jiffer1.c，生成的汇编为

.file "jiffier1.c"
.version "01.01"
gcc2_compiled.:
.text
.align 4
.globl main
.type main,@function
main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl $777, -4(%ebp)
leal -4(%ebp), %eax
incl (%eax)
movl $0, %eax
leave
ret
.Lfe1:
.size main,.Lfe1-main
.ident "GCC: (GNU) 2.96 20000731 (Red Hat Linux 7.3 2.96-110)"

从汇编中，可以看到jiffiers的值是直接在内存里加一的。

jiffier2.c

int main()
{
volatile unsigned long jiffiers = 777;

jiffiers++;

return 0;
}

生成的汇编为

.file "jiffier2.c"
.version "01.01"
gcc2_compiled.:
.text
.align 4
.globl main
.type main,@function
main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl $777, -4(%ebp)
movl -4(%ebp), %eax
incl %eax
movl %eax, -4(%ebp)
movl $0, %eax
leave
ret
.Lfe1:
.size main,.Lfe1-main
.ident "GCC: (GNU) 2.96 20000731 (Red Hat Linux 7.3 2.96-110)"

当jiffiers被声明为volatile时，在加一之前，会先从内存中将值读到寄存器%eax中，
直接都寄存器操作，完了以后不做cache，将值写回内存。它需要3条指令才完成了加一
操作，

movl -4(%ebp), %eax
incl %eax
movl %eax, -4(%ebp)

也就是说，jiffiers++并不是原子操作，在多处理器环境中，
问题就出来了，jiffers有可能被加了两次，内存中却只是加了1。
另外的原因是这3条指令执行的时候，可能会被重新排序，从而破坏了操作的原子性。
当然我们也可以直接调用汇编指令加一，但是do_timers函数是独立于体系结构的，
所以Linux使用的一种最简单的方法，也就是(*(unsigned long *)&jiffiers)++
来解决这些问题。

jiffier3.c

int main()
{
volatile unsigned long jiffiers = 777;

(*(unsigned long *)&jiffiers)++;

return 0;
}

生成的汇编为

.file "jiffier3.c"
.version "01.01"
gcc2_compiled.:
.text
.align 4
.globl main
.type main,@function
main:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl $777, -4(%ebp)
leal -4(%ebp), %eax
incl (%eax)
movl $0, %eax
leave
ret
.Lfe1:
.size main,.Lfe1-main
.ident "GCC: (GNU) 2.96 20000731 (Red Hat Linux 7.3 2.96-110)"

可以看出来，生成的指令和jiffer1.c的一模一样，也就是说，
(*(unsigned long *)&jiffiers)++将volatile的jiffiers转换成一般的内存变量，
避免了用寄存器做cache，从而保证了jiffiers加一操作的原子性。
Linux一开始也是直接用jiffiers++的，到后来的版本才改成(*(unsigned long *)&jiffiers)++，
可想而知写一个牢固的OS是不容易的，要解决的隐含细节非常多。
Good Luck, Linux!

test1.c
**************************
int i = 0; /*注意这里没有volatile*/
int main()
{
while( i==0 );
return 0;
}
**************************

首先编译没有优化的版本：

gcc -o test1 test1.c
objdump -d test1

0804841c <main>:
804841c: 55 push %ebp
804841d: 89 e5 mov %esp,%ebp
804841f: 90 nop
8048420: 83 3d 8c 95 04 08 00 cmpl $0x0,0x804958c
8048427: 74 f7 je 8048420 <main+0x4>
8048429: b8 00 00 00 00 mov $0x0,%eax
804842e: 5d pop %ebp
804842f: c3 ret

注意，生成的代码是直接用内存中的i和0比较的
这在多线访问时没有问题

接下来看看优化的版本

gcc -o test1 -O2 test1.c
objdump -d test1

0804841c <main>:
804841c: 55 push %ebp
804841d: 89 e5 mov %esp,%ebp
804841f: a1 8c 95 04 08 mov 0x804958c,%eax
8048424: 85 c0 test %eax,%eax
8048426: 74 fc je 8048424 <main+0x8> /*注意跳转的地址*/
8048428: 31 c0 xor %eax,%eax
804842a: 5d pop %ebp
804842b: c3 ret

看到了吧，将i的值装到了eax中，而且以后的循环中不会重新取i的值
如果进入循环时点值为0，即使i的值以后被其他的线程改变了，这个循环
“永远”也退不出来了。

下面在i的定义前加一个volatile修饰

test2.c
**************************
volatile int i = 0;
int main()
{
while( i==0 );
return 0;
}
**************************

gcc -o test2 -O2 test2.c
objdump -d test2

0804841c <main>:
804841c: 55 push %ebp
804841d: 89 e5 mov %esp,%ebp
804841f: 90 nop
8048420: a1 8c 95 04 08 mov 0x804958c,%eax
8048425: 85 c0 test %eax,%eax
8048427: 74 f7 je 8048420 <main+0x4> /*注意跳转的地址*/
8048429: 31 c0 xor %eax,%eax
804842b: 5d pop %ebp
804842c: c3 ret

这回不同了，每次循环都会到内存中将i的值重新装入寄存器eax并进行新的比较。
这样，在多线的环境下就没有问题了