浅析Java中volatile关键字

认识volatile关键字

        Java中的volatile关键字用于修饰一个变量，当这个变量被多个线程共享时，这个变量的值如果发生更新，每个线程都能获取到最新的值。volatile关键字在多线程环境下还会禁止指令重排序，确保变量的赋值操作按照代码的顺序执行。需要注意是它不能保证变量操作的原子性。

       简而言之， Java中的volatile关键字保证可见性，禁止指令重排序(有序性)。

volatile与内存屏障

        volatile通过内存屏障来保证可见性与有序性。

认识内存屏障

         内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。内存屏障其实就是一种JVM指令，Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性，但volatile无法保证原子性。

        内存屏障能阻止屏障两边的指令重排序，在写数据时加入屏障，强制将线程私有工作内存的数据刷回主物理内存，读数据加入屏障，线程私有工作内存的数据会失效，重新到主物理内存中获取最新数据。

内存屏障指令

volatile可见性

        volatile关键字保证可见性，当一个线程修改了volatile修饰的变量的值，这个变量修改后的值会立即刷新到主内存中，其他线程读取volatile修饰的变量的值时，会重新将主内存中该变量最新的值读取到线程自己的工作内存中。

    // 验证volatile的可见性
    private static volatile boolean flag = true;

    public static void main(String[] args) {

        // 开启一个线程
        new Thread(()->{
            // 如果为false，跳出循环并输出打印内容
            // 线程中读取的时候，每次读取都会去主内存中读取共享变量最新的值，
            // 然后将其复制到工作内存
            while (flag){

            }
            System.out.println("flag标志更新,线程结束");
        }).start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 主线程中修改volatile修饰的变量的值true->false
        // 主线程中修改了工作内存中变量的副本，修改之后会立即刷新到主内存
        flag = false;
    }

运行结果： 

volatile的读写过程分析

Java内存模型中定义的8种工作内存与主内存之间的原子操作

read(读取)→load(加载)→use(使用)→assign(赋值)→store(存储)→write(写入)→lock(锁定)→unlock(解锁)

read：作用于主内存，将变量的值从主内存传输到工作内存，主内存到工作内存
load：作用于工作内存，将read从主内存传输的变量值放入工作内存变量副本中，即数据加载
use：作用于工作内存，将工作内存变量副本的值传递给执行引擎，每当JVM遇到需要该变量的字节码指令时会执行该操作
assign：作用于工作内存，将从执行引擎接收到的值赋值给工作内存变量，每当JVM遇到一个给变量赋值字节码指令时会执行该操作
store：作用于工作内存，将赋值完毕的工作变量的值写回给主内存
write：作用于主内存，将store传输过来的变量值赋值给主内存中的变量
由于上述只能保证单条指令的原子性，针对多条指令的组合性原子保证，没有大面积加锁，所以，JVM提供了另外两个原子指令：
lock：作用于主内存，将一个变量标记为一个线程独占的状态，只是写时候加锁，就只是锁了写变量的过程。
unlock：作用于主内存，把一个处于锁定状态的变量释放，然后才能被其他线程占用

volatile禁止指令重排序

认识重排序

        重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段，有时候会改变程序语句的先后顺序(不存在数据依赖关系，可以重排序；存在数据依赖关系，禁止重排序)，但重排后的指令绝对不能改变原有的串行语义！这点在并发设计中必须要重点考虑！

        数据依赖性是指两个操作访问同一变量，且这两个操作中有一个为写操作，此时两操作间就存在数据依赖性。数据依赖性分为以下三种类型（这三种情况，只要重排序两个操作的执行顺序，程序的执行结果就会被改变）。

名称	代码示例	说明
写后读	a = 1; b = a;	写一个变量之后，再读这个位置
写后写	a = 1; a = 2;	写一个变量之后，在写这个变量
读后写	a = b; b = 1;	读一个变量之后，再写这个变量

重排序的分类和执行流程

编译器优化的重排序： 编译器在不改变单线程串行语义的前提下，可以重新调整指令的执行顺序。
指令级并行的重排序： 处理器使用指令级并行技术来讲多条指令重叠执行，若不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
内存系统的重排序： 由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是乱序执行。

volatile禁止指令重排序的行为

        当第一个操作为volatile读时，不论第二个操作是什么，都不能重排序。这个操作保证了volatile读之后的操作不会被重排到volatile读之前。

        当第二个操作为volatile写时，不论第一个操作是什么，都不能重排序。这个操作保证了volatile写之前的操作不会被重排到volatile写之后。

        当第一个操作为volatile写时，第二个操作为volatile读时，不能重排。

四大内存屏障插入

        写操作

        当前volatile写操作之前插入StoreStore屏障，禁止前面的普通写或volatile写操作与当前volatile写发送生重排序，并保证前面所有的普通写操作将数据已经刷新到主内存中。

        当前volatile写操作之前插入StoreLoad屏障，禁止后面的volatile读/写或普通写操作与当前volatile写重排序，并保证当前volatile写操作将数据刷新到内存中。

       读操作 

        当前volatile读操作之后插入LoadLoad屏障，禁止后面的普通读、volatile读和当前volatile都发生重排序。

        当前volatile读操作之后插入LoadStore屏障，禁止后面的普通写、volatile写和当前volatile都发生重排序。

volatile不保证原子性 

        原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。

        volatile变量的复合操作(如i++)不具有原子性，让我们从以下代码具体分析一下为什么 volatile变量的复合操作(如i++)不具有原子性。

        简单的代码示例如下，首先声明一个volatile修饰的int变量，在方法中对这个变量进行i++复合操作。

    private volatile int i;

    public void add(){
        i++;
    }

        通过javap -c <classname>命令对class文件进行反编译，如下：

 public void add();
    Code:
       0: aload_0
       1: dup
       2: getfield      #2                  // Field i:I 
       5: iconst_1
       6: iadd
       7: putfield      #2                  // Field i:I
      10: return
 }

         从编译过后可以看到，i++被拆分了三步执行：执行getfield指令获取字段i；执行iadd指令对i进行+1操作；执行putfield指令把累加后的值写回。如果有另一线程在当前线程读取旧值和写回新值期间读取i的域值，那么另一线程就会与当前线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程不安全，值操作从i=2变成了i=1，如果要保证线程安全，对于add方法就必须使用synchronized修饰。

        再往jvm层面深入分析，volatile为了保证内存可见性对其中的一些指令做了特殊处理，read(读取) - load(加载) - use(使用)必须连续出现以保证读的可见性；assign(赋值) - store(存储) - write(写入)必须连续出现将值写入主内存中。在这两组关联操作中存有极小的一段真空期，有可能变量值会被其他线程读取，导致写数据的丢失。

        
         

        《深入理解Java虚拟机》提到，由于volatile只能保证可见性，在不符合以下两条规则的运算场景中，我们仍然要通过加锁(使用synchronized、java.util.concurrent中的锁或原子类)来保证原子性：

• 运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值。
•  变量不需要与其他的状态变量共同参与不变约束。

 volatile的正确使用

复合运算赋值不能使用volatile关键字，会出现线程不安全问题。

    // 正确用法
    private volatile int count = 10;
    private volatile boolean flag = true;

可以作为状态标志，判断业务是否结束。

    private static volatile boolean flag = true;

    public static void main(String[] args) {

        new Thread(()->{
            while (flag){

            }
            System.out.println("flag标志更新,线程结束");
        }).start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        flag = false;
    }

当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销。

    private volatile int i;

    private int getVal(){
        return i; //利用volatile保证读取操作的可见性
    }

    public synchronized int increment(){
        return i++; //利用synchronized 保证复合操作的原子性
    } 

DCL双端锁实现单例

    private volatile static SafeDoubleCheckSingleton safeDoubleCheckSingleton;

    private SafeDoubleCheckSingleton(){

    }

    public static SafeDoubleCheckSingleton getInstance(){
        if (safeDoubleCheckSingleton == null){
            synchronized (SafeDoubleCheckSingleton.class){
                // 如果第一行不加volatile，在多线程环境下，
                //由于重排序，该对象可能还未完成初始化就被其他线程读取
                if (safeDoubleCheckSingleton == null){
                    safeDoubleCheckSingleton = new SafeDoubleCheckSingleton();
                }
            }
        }
        return safeDoubleCheckSingleton;
    }

总结：

• volatile是一种轻量级锁的实现，它针对的仅仅是共享变量，不会对线程加锁，更不会造成线程的阻塞。
• volatile保证内存可见性，当变量值更新时，其他共享该变量的线程从主内存获取最新的值。
• volatile通过内存屏障禁止指令重排序。
• volatile对于复合赋值操作不保证原子性，如果需要保证原子性，还是需要使用synchronized、java.util.concurrent中的锁或原子类。