Java并发编程-正确理解volatile关键字的两层语义

最新推荐文章于 2024-07-05 17:54:33 发布

记忆力不好

最新推荐文章于 2024-07-05 17:54:33 发布

阅读量3.5k

点赞数 2

分类专栏： Java并发编程文章标签： java volatile 并发多线程

本文链接：https://blog.csdn.net/chenchaofuck1/article/details/51702388

版权

Java并发编程专栏收录该内容

24 篇文章 8 订阅

订阅专栏

本文详细探讨了Java中volatile关键字的作用，指出其不能保证线程安全，但确保了变量的可见性和禁止指令重排序。通过对内存模型的解释，阐述了volatile如何保证线程间数据的即时同步，并通过实例分析了其在并发编程中的应用，如单例模式的Double-Check。

摘要由CSDN通过智能技术生成

关于关键字volatile可以说是Java虚拟机提供的轻量级的同步机制，但是它并不容易完全被正常、完整地理解，以至于许多程序员都不习惯去使用它，遇到需要处理多线程数据竞争问题的时候一律使用Synchronized来进行同步。了解volatile变量的语义对了解多线程操作的其他特性很有意义。本篇文章将结束volatile关键字的两类语义：可见性和禁止指令重拍序。

1.volatile不能保证线程安全：

volatile关键字是JAVA并行开发中非常重要的一个关键字，但却常被误以为其具有证原子性，实际上volatile修饰的便利不能保证线程安全，如：

[java]view plaincopy 
   
 private static volatile int  count=0;  
 public static void increase(){  
    count++;  
 }  
 public static void main(String[] args) {  
   
    for(int i=0;i<20;i++){  
       new Thread(new Runnable() {  
           public void run() {  
                 for(int i=0;i<10000;i++)  
                      increase();  
           }  
      }).start();  
  }  
  while(Thread.activeCount()>1){  
     Thread.yield();  
  };  
 System.out.println(count);  

这段代码创建20个线程对count自加操作，但最后count不是200000，每次运行的结果都不一样。

问题就在count++语句，用javap反编译就可以发现该语句由4条字节码指令构成，从字节码层面就很容易分析出原因：执行取值指令时，可以保证count是最新，但当执行iadd指令时，其他线程可能已经更新count了，而现在操作的count已经过期了，所以可能把较小的count同步回主内存中。

2.volatile的可见性：

可见性指当一个线程修改了一个共享变量的值，其他线程能够立即得知这个修改。要理解可见性必须要了解Java的内存模型。

Java的内存模型（JMM）：Java内存模型规定所有的变量都放在主内存中，每条线程都有自己的工作内存，线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取、赋值等）都在工作内存中进行，不能直接读写主内存中的变量。线程、工作内存、主内存交互关系如下：

（这里所讲得主内存、工作内存和Java内存区域的堆、栈、方法区等并不是同一个层次的内存划分）

工作内存和主内存的交互Java通过了几种原子操作：

lock：作用于主内存，把变量标识为线程独占状态。

unlock：作用于主内存，解除独占状态。

read：作用主内存，把一个变量的值从主内存传输到线程的工作内存。

load：作用于工作内存，把read操作传过来的变量值放入工作内存的变量副本中。

use：作用工作内存，把工作内存当中的一个变量值传给执行引擎。

assign：作用工作内存，把一个从执行引擎接收到的值赋值给工作内存的变量。

store：作用于工作内存的变量，把工作内存的一个变量的值传送到主内存中。

write：作用于主内存的变量，把store操作传来的变量的值放入主内存的变量中。

volatile普通变量与变量变量的区别是，volatile的特殊规则保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新，而普通变量则不能保证这一点。

volatile的特殊规则就是read、load、use必须连续出现。assign、store、write动作必须连续出现。所以使用volatile变量能够保证必须先从主内存刷新最新的值，每次修改后必须立即同步回主内存当中。

所以volatile的可见性很适合用来控制并发，如：

[java]view plaincopy 
   
 private static volatile boolean flag;  
 public void shutdown(){   
     flag=true;  
 }  
 public static void main(String[] args) {  
     Main m = new Main();  
     for(int i=0;i<20;i++){  
         new Thread(new Runnable() {               
             public void run() {  
                 while(!flag){  
                       
                 }  
             }  
         }).start();  
     }  
 }  

当调用shutdown()时，能保证所以线程立即停止。

3.volatile的禁止指令重排序：

在Java中普遍的变量仅仅会保证在该方法的执行过程中所有依赖的赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。因为在一个线程的方法执行过程中无法感知到这点，这也就是Java内存模型中描述的所谓“线程内表现为串行的语义”。

有序性

　　在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虚拟机》。

　　这8条规则中，前4条规则是比较重要的，后4条规则都是显而易见的。

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

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

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

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

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

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是可见的。

使用的场景（单例模式的Double-Check）

　　指令重排序是并发编程中最容易开发人员产生疑惑的地方，除了上面伪代码的例子之外，笔者再举一个可以实际操作运行的例子分析volatile关键字是如何禁止指令重排序优化的。下面代码是一段标准的DCL单例代码，可以观察volatile加入和未加入时所生产汇编代码的差别。

public class Singleton{
    private volatile static Singleton instance = null;
     
    private Singleton() {
      
  }
     
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
  	      }
        }
        return instance;
    }
}

如果上面代码中的instance不使用volatile，这段代码可能出现问题，可能出现把未进行初始化的对象赋值给instance，这时instance

已经是非null了，如果在其他现在当中使用这个未被初始化的对象将会出现安全问题。

关于单例模式的双重检查机制查看： Java单例模式中双重检查锁的问题