详解Java线程编程中的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特性的一个好方法是：把对volatile变量的单个读/写，看成是使用同一个监视器锁对这些单个读/写操作做了同步。下面我们通过具体的示例来说明，请看下面的示例代码：

class volatilefeaturesexample {
  volatile long vl = 0l; //使用volatile声明64位的long型变量

  public void set(long l) {
    vl = l;  //单个volatile变量的写
  }

  public void getandincrement () {
    vl++;  //复合（多个）volatile变量的读/写
  }


  public long get() {
    return vl;  //单个volatile变量的读
  }
}

假设有多个线程分别调用上面程序的三个方法，这个程序在语意上和下面程序等价：

class volatilefeaturesexample {
  long vl = 0l;        // 64位的long型普通变量

  public synchronized void set(long l) {   //对单个的普通 变量的写用同一个监视器同步
    vl = l;
  }

  public void getandincrement () { //普通方法调用
    long temp = get();      //调用已同步的读方法
    temp += 1l;         //普通写操作
    set(temp);          //调用已同步的写方法
  }
  public synchronized long get() { 
  //对单个的普通变量的读用同一个监视器同步
    return vl;
  }
}

如上面示例程序所示，对一个volatile变量的单个读/写操作，与对一个普通变量的读/写操作使用同一个监视器锁来同步，它们之间的执行效果相同。

监视器锁的happens-before规则保证释放监视器和获取监视器的两个线程之间的内存可见性，这意味着对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。

3.volatile写-读建立的happens before关系

上面讲的是volatile变量自身的特性，对程序员来说，volatile对线程的内存可见性的影响比volatile自身的特性更为重要，也更需要我们去关注。

从jsr-133开始，volatile变量的写-读可以实现线程之间的通信。

从内存语义的角度来说，volatile与监视器锁有相同的效果：volatile写和监视器的释放有相同的内存语义；volatile读与监视器的获取有相同的内存语义。

请看下面使用volatile变量的示例代码：

class volatileexample {
  int a = 0;
  volatile boolean flag = false;

  public void writer() {
    a = 1;          //1
    flag = true;        //2
  }

  public void reader() {
    if (flag) {        //3
      int i = a;      //4
      ……
    }
  }
}

假设线程a执行writer()方法之后，线程b执行reader()方法。根据happens before规则，这个过程建立的happens before 关系可以分为两类：

根据程序次序规则，1 happens before 2; 3 happens before 4。
根据volatile规则，2 happens before 3。
根据happens before 的传递性规则，1 happens before 4。
上述happens before 关系的图形化表现形式如下：

在上图中，每一个箭头链接的两个节点，代表了一个happens before 关系。黑色箭头表示程序顺序规则；橙色箭头表示volatile规则；蓝色箭头表示组合这些规则后提供的happens before保证。

这里a线程写一个volatile变量后，b线程读同一个volatile变量。a线程在写volatile变量之前所有可见的共享变量，在b线程读同一个volatile变量后，将立即变得对b线程可见。

4.volatile写-读的内存语义

volatile写的内存语义如下：

当写一个volatile变量时，jmm会把该线程对应的本地内存中的共享变量刷新到主内存。
以上面示例程序volatileexample为例，假设线程a首先执行writer()方法，随后线程b执行reader()方法，初始时两个线程的本地内存中的flag和a都是初始状态。下图是线程a执行volatile写后，共享变量的状态示意图：

如上图所示，线程a在写flag变量后，本地内存a中被线程a更新过的两个共享变量的值被刷新到主内存中。此时，本地内存a和主内存中的共享变量的值是一致的。

volatile读的内存语义如下：

当读一个volatile变量时，jmm会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。
下面是线程b读同一个volatile变量后，共享变量的状态示意图：

如上图所示，在读flag变量后，本地内存b已经被置为无效。此时，线程b必须从主内存中读取共享变量。线程b的读取操作将导致本地内存b与主内存中的共享变量的值也变成一致的了。

如果我们把volatile写和volatile读这两个步骤综合起来看的话，在读线程b读一个volatile变量后，写线程a在写这个volatile变量之前所有可见的共享变量的值都将立即变得对读线程b可见。

下面对volatile写和volatile读的内存语义做个总结：

线程a写一个volatile变量，实质上是线程a向接下来将要读这个volatile变量的某个线程发出了（其对共享变量所在修改的）消息。
线程b读一个volatile变量，实质上是线程b接收了之前某个线程发出的（在写这个volatile变量之前对共享变量所做修改的）消息。
线程a写一个volatile变量，随后线程b读这个volatile变量，这个过程实质上是线程a通过主内存向线程b发送消息。

5.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的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。

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

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

　　解释到这里，可能有朋友会有疑问，不对啊，前面不是保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到新的值，对，这个没错。这个就是上面的happens-before规则中的volatile变量规则，但是要注意，线程1对变量进行读取操作之后，被阻塞了的话，并没有对inc值进行修改。然后虽然volatile能保证线程2对变量inc的值读取是从内存中读取的，但是线程1没有进行修改，所以线程2根本就不会看到修改的值。

　　根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

　　把上面的代码改成以下任何一种都可以达到效果：

　　采用synchronized：

public class test {
  public int inc = 0;
  
  public synchronized 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);
  }
}

　　采用lock：

public class test {
  public int inc = 0;
  lock lock = new reentrantlock();
  
  public void increase() {
    lock.lock();
    try {
      inc++;
    } finally{
      lock.unlock();
    }
  }
  
  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);
  }
}

　　采用atomicinteger：

public class test {
  public atomicinteger inc = new atomicinteger();
   
  public void increase() {
    inc.getandincrement();
  }
  
  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);
  }
}

　　在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作类，即对基本数据类型的 自增（加1操作），自减（减1操作）、以及加法操作（加一个数），减法操作（减一个数）进行了封装，保证这些操作是原子性操作。atomic是利用cas来实现原子性操作的（compare and swap），cas实际上是利用处理器提供的cmpxchg指令实现的，而处理器执行cmpxchg指令是一个原子性操作。

6.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已经初始化完毕。