Java中的volatile关键字

标签：volatile   多线程   

一、计算机内存模型的相关概念

    计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，可能会涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢得多，因此如果任何时刻对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度，因此自CPU里面就有了高速缓存。

    也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU高速缓存中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。比如下面这条语句：

i = i + 1;

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

    假设同时有2个线程执行这段代码，i的初始值为0，我们本意是两个线程执行完之后i的值变为2，但事实会是这样吗？请看下面这种情况：

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

    最终结果是1，而不是2。这就是著名的缓存一致性问题。通常称这种被多个线程访问的变量为共享变量。也就是说，如果一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。

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

1.原子性

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

2.可见性

    可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。请看下面这段代码：

//线程1执行的代码
int i = 0;
i = 10;
 
//线程2执行的代码
j = i;

3.有序性

    有序性：即程序执行的顺序按照代码的先后顺序执行。举个简单的例子，看下面这段代码：

int i = 0;               
boolean flag = false;
i = 1;                //语句1   
flag = true;          //语句2

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

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2
 
//线程2:
while(!inited ){
  sleep() 
}
doSomethingwithconfig(context);

三、Java内存模型

    Java内存模型规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。也就是说，在java内存模型中，也会存在缓存一致性问题和指令重排序的问题。

1.原子性

    在Java中，对基本数据类型（除了long和double）的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。还有一些原子类，如AtomicInteger、AtomicBoolean等等。

2.可见性

    对于可见性，Java提供了volatile关键字来保证可见性。
    当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
    而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
    另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

3.有序性

    在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
    在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

四、深入剖析volatile关键字

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

• 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这个新值对其他线程来说是立即可见的；
• 禁止进行指令重排序。

//线程1
boolean stop = false;
while(!stop){
    doSomething();
}
 
//线程2
stop = true;

    但是用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没办法保证对变量的操作的原子性。

    要保证具有原子性，可以使用synchronized关键字、Lock、原子变量(AtomicInteger等)

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

    我们再来看前面所举得那个例子：

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2
 
//线程2:
while(!inited ){
  sleep() 
}
doSomethingwithconfig(context);

4.volatile的原理和实现机制

    前面讲述了源于volatile关键字的一些使用，下面我们来探讨一下volatile到底如何保证可见性和禁止指令重排序的。
    下面这段话摘自《深入理解Java虚拟机》：
    “观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”
    lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：
      1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
      2）它会强制将对缓存的修改操作立即写入主存；
      3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

五、使用volatile关键字的场景

    一般来说：当一个变量的值的修改不依赖原来的值时，就满足了volatile关键字的使用场景。 

场景1. get方法

private volatile int value = 0;  
  
public void setValue(int value){  
    this.value = value;  
}  
  
public int getValue(){  
    return value;  
}  

场景2. 状态标记量

volatile boolean flag = false;
 
while(!flag){
    doSomething();
}
 
public void setFlag() {
    flag = true;
}

volatile boolean inited = false;
//线程1:
context = loadContext();   
inited = true;             
 
//线程2:
while(!inited ){
sleep() 
}
doSomethingwithconfig(context);

• volatile是在synchronized性能低下的时候提出的。如今synchronized的效率已经大幅提升，所以volatile存在的意义不大。
• 如今非volatile的共享变量，在访问不是超级频繁的情况下，已经和volatile修饰的变量有同样的效果了。
• volatile不能保证原子性，这点是大家没太搞清楚的，所以很容易出错。
• volatile可以禁止重排序。

参考资料：

http://www.cnblogs.com/dolphin0520/p/3920373.html

http://www.cnblogs.com/mengheng/p/3495379.html

Java中的volatile关键字

标签：volatile   多线程   

原文地址：http://blog.csdn.net/huhui_cs/article/details/38848641