对volatile关键字的理解

转自：http://www.importnew.com/18126.html

volatile关键字我们经常在java并发编程中见到，和volatile经常提到的也有synchronized关键字，这两个关键字都是和java并发有很紧密的关系，我们今天就先说一下volatile关键字。

volatile关键字和java内存模型有关，所以我们在了解volatile关键字之前先要了解一下java内存模型的有关知识。

一. 内存模型的有关概念

我们都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而在执行指令的过程中势必会涉及到数据的读取与写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这就存在一个问题，CPU的执行速度很快，而从内存中读取数据和向内存写入数据的过程和CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存来解决这一问题。

所以说，在程序运行过程中，会将运算需要的数据从主存拷贝一份到CPU的高速缓存中，当CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。举个例子，如下面这段代码：

i= i+1；

当线程执行这个语句时，会先从主存中读取 i 的值，然后复制一份到高速缓存当中，然后CPU执行指令对 i 进行加 1 操作，然后将数据写入高速缓存，最后将高速缓存中的 i 最新值刷新到主存当中。

这个代码在单线程中运行是没有任何问题的，但是在多线程中运行就会有问题。在多核CPU中，每个线程可能运行于不同的CPU中，因此每个线程运行时有自己的高速缓存（对单核CPU来说，也会出现这种问题，只不过是以线程调度的形式来分别执行的）。本文我们以多核CPU为例。

 

比如同时有2个线程执行这段代码，假如初始时i的值为0，那么我们希望这两个代码执行完后i的值变为2，但事实会是怎样？

可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存中，然后线程1进行加1操作，然后把i的最新值1写入内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。

最终的结果i 的值是1，而不是2.这就是著名的缓存一致性问题。通常称这种被多个线程访问的变量为共享变量。

也就是说，如果一个变量在多个CPU中都存在缓存（一般在多线程编程中出现），那么就可能存在缓存不一致的问题。、

为了解决缓存不一致性问题，通常来说有以下2中解决办法：

1） 通过在总线加LOCK#锁的方式

2） 通过缓存一致性协议

这两种方式都是在硬件层面上提供的方式。

 

在早期的CPU中，是通过在总线上加LOCK#锁的形式来解决缓存不一致的问题。因为CPU和其他部件进行通信都是通过总线来进行的，如果对总线加LOCK#锁的话，也就是阻塞了其他CPU对其他部件的访问（如内存），从而使得只能有一个CPU能使用这个变量的内存。如上面例子中，如果一个线程在执行 i = i + 1 ,如果在执行这段代码的过程中，在总线上发出了LOCK#锁的信号，那么只有等待这段代码完全执行完毕之后，其他CPU才能从变量 i 所在的内存中读取变量，然后进行相应的操作。这就解决了缓存不一致的问题。

但是上面的方式会有一个问题，由于在锁住总线期间，其他的CPU无法访问内存，导致效率低下。

所以就出现了缓存一致性协议。最出名的就是Intel的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它的核心思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他的CPU中也存在该变量的副本，就会发出信号通知其他的CPU将该变量的缓存行置为无效状态，因此当其他的CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存中重新读取。

二. 并发编程中的三个概念

原子性问题，可见性问题，有序性问题。

1.原子性

原子性：即一个操作或者多个操作要么全部执行并且执行过程不会被任何因素打断，要么就都不执行。

举个简单的例子，我们假设一个32位的变量赋值过程不具备原子性的话，会发生什么后果？

i= 9；

假如一个线程执行到这个语句时，暂且假设为一个32位的变量赋值包括两个过程：为低16位赋值，为高16位赋值。

那么就可能发生一种情况：当将低16位数值写入之后，突然被中断，而此时又有一个线程去读取 i 的值，那么读取到的就是错误的数据。

2. 可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立刻看到修改的值。

举个简单的例子，看下面这段代码：

//线程1执行的代码

int i=0;

i=10;

 

//线程2执行的代码

j=i;

假若执行线程1的是CPU1，执行线程2的是CPU2，由上面的分析可知，当线程1执行到i=10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的 值变为10了。却没有立即写入到主存当中。

当时线程2执行j=i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10。

这就是可见性问题，线程1对变量i修改之后，线程2没有立即看到线程1修改的值。

3. 有序性

有序性：即程序执行的顺序按照代码的先后顺序执行，举个例子：

int i=0;

boolean flag= false;

i=1; // 语句1

flag = true;  // 语句2

上面的代码定义了一个int型变量，定义了一个boolean型变量，然后分别对这两个变量进行赋值操作，从代码顺序上看，语句1是在语句2前面的，那么JVM真正在执行这段代码的时候会保证语句1一定在语句2前面吗？不一定，这里会发生指令重排序。

 

解释一下什么是指令重排序，一般来说，处理器为了提高程序的运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终的执行结果和代码顺序执行的结果是一致的。

如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

但是注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证呢？再看下面一个例子：

int a = 10;  //语句1

int r = 2;  // 语句2

a = a+3;  // 语句3

r = a*a; // 语句4

这段代码有4个语句，那么可能的一个执行顺序是：语句 2 ，语句1 ，语句3， 语句4，那么可不可能是这个执行顺序：语句 2 ，语句1 ，语句4， 语句3，

不可能，因为处理器在进行重排序时会考虑指令之间的数据依赖性，如果一个指令Instruction 2 必须用到 Instruction 1的结果，那么处理器会保证Instruction 1 会在Intsruction 2 之前执行。

虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：

// 线程1

context = loadContext(); // 语句1

inited = true; // 语句2

 

// 线程2

while(!inited){

sleep();

}

doSomethingwithconfig(context);

上面的代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此时线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。

从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

也就是说，要想并发程序正确地执行，必须要保证原子性，可见性，以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

 

三. Java内存模型

前面我们谈到一些关于内存模型以及并发编程中可能会出现的一些问题。下面我们来看一下Java内存模型，研究一下Java内存模型为我们提供了哪些保证以及在Java中提供哪些方法和机制来让我们在进行多线程编程时能够保证程序执行的正确性。

在Java虚拟机规范中试图定义一种Java内存模型（Java Memory Model，JMM）来屏蔽各个硬件平台和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。那么Java内存模型规定了哪些东西呢？它定义了程序中变量的访问规则，往大一点说就是定义了程序执行的次序。注意，为了 获得较好的执行性能，Java内存模型并没有限制执行引擎使用处理器的寄存器或者高速缓存来提升指令执行速度，也就是没有限制编译器对指令进行重排序。也就是说，在Java内存模型中，也会存在缓存一致性问题和指令重排序的问题。

Java内存模型规定所有的变量都是存储在主存当中（类似前面说的物理内存），每个线程都有自己的工作内存（类似前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。

举个例子，在java中执行下面这个语句：

i= 10；

执行线程必须先在自己的工作线程中对变量i所在的缓存进行赋值操作，然后再写入主存当中。而不是直接将数值10写入主存当中。

那么Java语言对原子性，可见性以及有序性提供了哪些保证呢？

1.原子性

在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么 执行，要么不执行。

我们看一下下面的例子，请分析以下哪些是原子性操作：

x = 10 ; // 语句1

 y = x ;  //语句2

x++;  //语句3

x = x+1;  //语句4

乍一看，有些人可能会说上面的4个语句都是原子操作。其实只有语句1是原子性操作，其他三个语句都不是原子性操作。

语句1是直接将数值10赋值给x，也就是说线程执行这个语句会直接将数值10写入到工作内存中。

语句2实际包含2个操作，它要先去读取x的值，再将x的值写入工作内存，虽然读取x的值以及将x的值写入工作内存，这2个操作都是原子操作，但是合起来就不是原子操作了。

同样的，x++和x=x+1包括3个操作：读取x的值，进行加1操作，写入新的值。

所以上面的4个 语句只有语句1是原子操作。

也就是说，只有简单的读取，赋值（而且必须将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

不过有一点要注意：在32位平台下，对64位数据的读取和赋值是需要通过两个操作来完成的，不能保证其原子性。

从上面可以看出，Java内存模型只保证了基本读取和赋值时原子操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

2. 可见性

对于可见性，Java提供了volatile关键字来保证可见性。

当一个共享变量被volatile修饰时，它会保证修饰的值会立刻被更新到主存，当有其他的线程需要读取时，它会去主存中读取新值。

而普通的共享变量不能保证可见性，因为普通共享变量被修改以后，什么时候被写入主存是不确定的，当其他的线程去读取时，此时主存中的值可能还是原来的旧值，因此无法保证可见性。

另外。通过synchronized和Lock也能保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将变量的修改刷新到主存当中，因此可保证可见性。

3. 有序性

在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程中不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

在Java中，可以通过volatile关键字来保证一定的”有序性“。另外可以通过synchronized和Lock来保证有序性。显然，synchronized和Lock保证每个时刻是有一个线程执行到同步代码，相当于让线程顺序执行同步代码，自然就保证了有序性。

另外，Java内存模型具备一些先天的”有序性“，既不需要通过任何手段就能得到保证的有序性，这个也称为 happens-before原则。如果两个操作的执行顺序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意的对它们进行重排序。

下面介绍一下happens-before原则（先行发生原则）：

- 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作优先发生于书写在后面的操作

- 锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作

- volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的都操作

- 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C

- 线程启动规则：Thread对象的start（）方法先行发生于此线程的每一个动作

- 线程中断规则：对线程interrupt（）方法的调用先行发生于被中断线程的代码检测到中断事件的发生、

- 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束，Thread.isAlive()的返回值手段检测到线程已经终止执行。

- 对象终结规则： 一个对象的初始化完成先行发生于它的finalize（）方法的开始

这8条原则摘自《深入理解Java虚拟机》

我们来解释一下前4条规则：

对于程序次序来说，我的理解就是一段程序代码的执行在单个线程中看起来是有序的，注意，虽然这条规则中提到”书写在前面的操作先行发生于书写在后面的操作“，这个应该是程序看起来执行的顺序是按照代码顺序执行的，因为虚拟机可能会对程序代码指令进行重排序。虽然进行重排序，但是最终执行结果和顺序执行的结果是一致的，它只会对不存在的数据依赖性的指令进行重排序。因此，在单个线程中，程序执行看起来是有序执行的，这一点要注意理解。事实上，这个规则是用来保证程序在单线程中执行结果的正确性，但无法保证程序在多线程中执行的正确性。 

第二条规则也比较容易理解，也就是说无论早单线程中还是多线程中，同一个锁如果出于被锁定的状态，那么必须先行对锁进行释放，后面的才能继续进行lock操作。

第三条比较重要，直观的解释就是，如果一个线程先去写入一个变量，然后一个线程去进行读取，那么写入操作肯定会先行发生于读操作。

第四条实际就是体现happens-before原则具备传递性。

四. 深入解析volatile关键字

前面讲的那么多，都是为了讲解volatile关键字进行铺垫，下面直接进入主题。

1.volatile关键字的两层语义

一旦一个共享变量（类的成员变量，类的静态变量）被volatile修饰以后，那么就具备了两层语义：

1） 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程是立即可见的。

2） 禁止进行指令重排序

先看一段代码 ，假设线程1先执行，线程2后执行：

// 线程1

boolean stop= false;

while(!stop){

    doSomething();

}

// 线程2

stop = true;

这段代码一定会完全运行正确吗？即一定会将线程中断吗？不一定，也许在大多数时候线程可以被中断，但也有可能会导致无法中断线程（虽然这个可能性小，但是一旦发生就会出现死循环）

下面解释一下这段代码为何有可能导致无法中断线程。在前面已经解释过，每个线程在运行过程中都有自己的工作内存，那么线程1在运行的时候，会将stop变量的值拷贝一份到自己的 工作内存中。

那么当线程2更改了stop变量的值之后，但是还没来得及写入主存当中，线程2转去做其他的事情，那么线程1由于不知道线程2对stop变量的修改，因此还会一直循环下去。

但是使用volatile修饰之后就会变得不一样:

第一：使用volatile关键字会强制将修改的值立即写入主存；

第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；

第三：由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

那么在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得线程1的工作内存中缓存变量stop的缓存行无效，然后线程1读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后，然后去对应的主存读取最新的值。

那么线程1读取到的就是最新的正确的值。

2. volatile保证原子性吗？

从上面知道volatile关键字保证了操作的可见性，但是volatile能保证对变量的操作是原子性吗？

 

public class Test {

    public volatile int inc = 0;

 

    public void increase() {

        inc++;

    }

 

    public static void main(String[] args) {

        final Test test = new Test();

        for(int i=0;i<10;i++){

            new Thread(){

                public void run() {

                    for(int j=0;j<1000;j++)

                        test.increase();

                };

            }.start();

        }

 

        while(Thread.activeCount()>1)  //保证前面的线程都执行完

            Thread.yield();

        System.out.println(test.inc);

    }

}

这里大家 想一下这段程序的输出结果是多少？也许有些人认为是10000，但事实上运行他会发现每次的运行结果都不一致，都是一个小于10000的数字。

可能会有人提出疑问，上面是对变量inc进行自增操作，由于volatile保证了可见性，那么在每个线程中队inc自增完后，在其他线程中都能看到修改后的值，所以有10个线程分别进行了1000此操作，那么最终inc的值应该是1000*10=10000.

前面提到过，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证变量的操作的原子性。

自增操作是不具备原子性的，它包括读取变量的原始值，进行加1操作，写入工作内存。那么就是说自增操作的三个操作可能会被分割执行，就有可能导致下面的情况出现：

假设某个时刻变量inc的值为10，

线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；

然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于是线程2是第一次读取inc的值，所以线程2会直接去主存读取inc的值，发现inc的值为10，然后进行加1操作，并把11写入工作内存，最后写入主存。

然后线程1接着进行加1操作，由于已经读取了inc的值，此时线程1的工作内存中inc的值仍为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

两个线程分别进行了一次自增操作后，inc只增加了1.

到这里，可能有人会问，前面不是保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到最新的值，这里我结合别人的理解是：上面线程1在刚开始读取inc的值时，由于第一次读取，直接从主存读取inc的 值，保存到自己的工作内存，这里线程1此时的工作内存的缓存行不会置为无效，然后就是线程2进行第一次读取inc的值，然后修改完成写入主存，此时线程1执行的时候，由于上面已经读取过了，现在只是使用此变量而不是读取，所以不会检查缓存行是否有效或者无效（这里可以理解缓存行是和读取数据的操作绑定的，当你读取数据的时候才会检查缓存行是否有效，当你数据读取完成后，缓存行在以后就不会再次检查，只有当你下一次重新读取的时候，当发现修改了inc变量，此时才会直接去主存中去读，如果没有其他线程没有修改inc变量，那么线程1的缓存行就是有效的，就不会去主存中去重新读inc变量的值，就直接从线程1的工作内存中去读inc变量的值，其实在每次（不包括第一次）读取volatile变量之前都会检查该线程的工作内存的缓存行是否有效，才决定去主存还是工作内存中去读取数据）。

我们可以使用很多方法解决这个问题，如在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作类，即对基本的数据类型的自增，自减，以及加法，加法操作进行了封装，保证这些操作都是原子操作。atomic是利用CAS来实现原子操作的（Compare And Swap）,CAS实际上是利用处理器提供的CMPXCHG指令实现的，而处理器执行CMPXCHG指令是一个原子性操作。

3. volatile能保证有序性吗？

前面提到volatile关键字能禁止指令重排序，所以volatile能在一定程度上保证有序性。

volatile关键字禁止指令重排序有两层意思：

1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经执行，且结果已经对后面的操作可见；在其后面的操作肯定还没有执行；

2）在进行指令优化时，不能将在对volatile变量前面的语句放在其后面执行，也不能把volatile变量后面的语句放在其前面执行。

举个例子：

 // x,y为非volatile变量

// flag为volatile变量

x = 2;  //语句1

y = 0;  // 语句2

flag = true;  // 语句3

x = 4;  // 语句4

y = -1;  //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1，语句2前面，也不会将语句3放到语句4，语句5后面。但是注意：语句1和语句2，语句4和语句5的顺序是不做任何保证的。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕的，且语句1和语句2的执行结果是对语句3，语句4，语句5是可见的。

我们回到前面举得一个例子：

 

// 线程1

context = loadContext(); // 语句1

inited = true; // 语句2

 

// 线程2

while(!inited){

sleep();

}

doSomethingwithconfig(context);

前面举这个例子的时候，提到有可能语句2会在语句1之前执行，那么就可能导致context还没被初始化，而线程2中就使用未被初始化的context去进行操作，导致程序出错。

这里如果用volatile关键字对inited变量进行修饰，就不会出现这种问题了，因为当执行到语句2时，必定能保证context已经初始化完毕。

（volatile关键字其实就相当于一个分界线，分界线后面不可能跑到分界线前面去。分界线前面的也不可能跑到分界线后面去，并且执行到分界线的时候，分界线前面的操作肯定也执行完毕了）

4.volatile的原理和实现机制

我们下面讨论一下volatile到底如何保证可见性和禁止指令重排序。

下面这段话摘自《深入理解Java虚拟机》：

”观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令“

lock前缀指令实际上相当于一个内存屏障（也称内存栅栏），内存屏障会提供三个功能：

1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

2）它会强制将对缓存的修改操作立即写入主存；

3）如果是写操作，它会导致其他CPU对应的缓存行无效。

五. 使用volatile关键字的场景

synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行的效率，而volatile关键字在某些情况下性能 要优于synchronized，但volatile无法保证操作的原子性。通常来说，使用volatile必须具备以下两个条件：

1）对变量的写操作不依赖于当前值

2）该变量没有包含在具有其他变量的不变式中

实际上，这些条件表明，可以被写入volatile变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

使用场景如状态标记量。