深入理解volatile关键字

volatile是一个非常重要的关键字，用来修饰实例变量和类变量，以保证线程安全。想理解它的底层原理需先认识JVM内存模型和CPU缓存模型相关知识。

一、CPU缓存模型

计算机所有的运算操作都是由CPU在寄存器中完成，CPU指令执行过程需要对主内存中的数据进行读和写操作。而CPU的处理速度是内存访问速度的上千倍，CPU通过直连内存的方式访问数据将导致CPU资源收到极大限制，降低CPU的吞吐量。于是有了在CPU与内存之间增加缓存的设计。

缓存的出现极大地提高了CPU的吞吐能力，但是同时也引入了缓存不一致的问题。比如i++操作，它包含以下4个步骤：

• 读取主内存的i到缓存中
• 对i进行加1操作
• 将结果写回缓存中
• 将缓存刷新到主内存中

在多线程中，该操作很有可能出现两个线程都对共享资源i加1之后i的值只加了1的情况，这就是典型的缓存不一致问题。为了解决缓存不一致问题，通常有两种方法：总线加锁、缓存一致性协议。总线加锁会导致效率低下，所以一般通过缓存一致性协议的方式解决缓存不一致问题，主要有以下操作：

• 读取操作，不做任何处理，直接读取缓存
• 写入操作，发出信号通知其他其他CPU将该变量置为无效，其他CPU在进行该变量读取时必须从主任村重新获取。

二、并发编程的三个特性

并发编程包括三个至关重要的特性，原子性、可见性和有序性
1、原子性
（1）概念
原子性是指一次或多次操作中，所有的操作要么全部被执行并且不会受到干扰和打断，要么全部不执行。
（2）JMM（java内存模型）如何保证原子性
JVM采用内存模型机制屏蔽各平台和操作系统之间的差异，JVM内存模型规定所有变量都存在于主内存（RAM）中，而每个线程都有自己的工作内存（就像CPU的缓存），线程对变量的操作必须在自己的工作内存中进行，不能直接对主内存进行操作，也不能访问其他线程的工作内存。
在JVM中，简单的读取和赋值操作是原子性的，将一个变量赋值给另一个变量不是原子性的。如果想要使得某代码片段具有原子性，需要使用synchronized关键字，或者JUC中的lock。
（3）代码示例

        int x = 10;//原子性
        int y = x;//非原子性
        y++;//非原子性

（4）总结
volatile关键字不能保证原子性

2、可见性
（1）概念
可见性是指当一个线程对共享变量进行了修改，另外的线程可以立即看到修改后的最新值。
（2）JMM如何保证可见性
一个线程对共享变量进行修改操作，则先将修改后的值写入工作内存，然后刷新至主内存中，至于什么时候刷新至主内存是不确定的，其他线程不能立即得到最新值。java提供以下三种方式保证可见性：

• 使用volatile关键字：当一个变量被volatile关键字修饰，一个线程在自己的工作内存对其进行修改操作，会将修改后的新值立即刷新至主内存，并导致其他线程的工作内存中的该变量失效。其他线程想要使用该变量必须重新从主内存中读取。
• 通过synchronized关键字：通过锁机制的排他性，确保锁释放之前已将修改的值刷新到主内存。
• 通过JUC提供的显示锁Lock保证可见性。

（3）代码示例

import java.util.concurrent.TimeUnit;

public class VolatileFoo {
    //init_value的最大值
    final static int MAX=5;
    //init_value的初始值
    static volatile int init_value=0;

    public static void main(String[] args) {
        //Reader线程，当发现localValue和init_value不一致时，输出init_value被修改的信息
        new Thread(()->{
            int localValue = init_value;
            while(localValue<MAX){
                if (init_value!=localValue){
                    System.out.printf("init_value的值已更新为[%d]\n",init_value);
                    localValue = init_value;
                }
            }
        },"Reader").start();
        //Updater线程，用于对init_value进行修改
        new Thread(()->{
            int localValue = init_value;
            while(localValue<MAX){
                System.out.printf("init_value的值将修改为[%d]\n",++localValue);
                init_value=localValue;
                try {
                    //短暂休眠，目的是使Reader线程能够来得及输出内容
                    TimeUnit.MILLISECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Updater").start();
    }
}

（4）总结
volatile关键字能保证可见性

3、有序性
（1）概念
有序性是指代码的执行顺序。
（2）JMM如何保证有序性
java会在编译或者运行阶段对生成的指令进行优化，导致代码未必是开发者编写的顺序。这就是指令的重排序。指令的重排序会严格遵守指令之间的数据依赖关系，比如：

        int a = 10;//①
        int b = 5;//②
        a++;//③
        b=a+1;//④

在单线程情况下，对于这段代码有可能它的执行顺序就是代码本身的顺序，也有可能发生重排序导致②在①之前执行，但不可能发生④在③之前执行的情况。无论怎样重排序总能保证执行结果与顺序执行的结果保持一致。但是在多线程的情况下，如果有序性得不到保证，可能会使程序出现错误。比如以下代码：

public class Test06 {
    //此处可以使用volatile关键字改善代码
    private boolean flag = false;
    private Object object;

    public Object getObject() {
        if(flag){
            object = new Object();//①
            flag = true;//②
        }
        return object;
    }
}

在单线程情况下上述代码无论怎么重排序，getObject方法总能返回可用的对象。但是在多线程情况下，如果②重排序到①之前执行，比如线程A先执行②再执行①，再执行完②还未来得及执行①的时候，线程B进入方法，此时判断flag为true，直接跳过if执行return，就返回了一个空对象。
java提供三种保证有序性的方式：

• 使用volatile关键字
• 使用synchronized关键字
• 使用显示锁Lock保证有序性

（3）总结
volatile关键字能保证有序性

三、volatile的原理和实现机制

volatile有保证程序可见性和有序性的语义，被volatile关键字修饰的变量的机器指令存在一个“lock;”前缀，它相当于一个内存屏障，该屏障会对指令执行提供以下几个保障：

• 确保指令重排序时不会将其前面的代码排到内存屏障的后面
• 确保指令重排序时不会将其后面的代码排到内存屏障的前面
• 确保执行到内存屏障时，其前面的代码全部执行完成
• 强制将volatile变量修饰的值从工作内存刷新到主内存
• 如果是写操作，会使其他所有线程的工作内存中的该变量失效

以上几个保障使得volatile关键字具有以下两个语义：

• 可见性：当一个线程对volatile关键字修饰的变量进行修改，其他线程会立即看到该变量的最新值
• 有序性：禁止对指令进行重排序操作

四、volatile与synchronized关键字比较

1、使用上的区别

• volatile关键只能修饰实例变量或类变量，不能修饰方法、局部变量和常量；synchronized只能修饰方法或者语句块，不能修饰变量
• volatile修饰的变量可以为null，synchronized修饰语句块的锁定对象不能为null

2、关于三大特性的区别

• 原子性：volatile不保证原子性；synchronized通过锁机制的排他性保证原子性
• 可见性：两者均保证可见性，但实现机制完全不同。volatile通过机器指令“lock;”使其他线程工作内存中的数据失效，不得不从主内存中加载；synchronized借助JVM指令monitorenter和monitorexit使同步代码串行化，在monitorexit执行时所有共享资源刷新到主内存中。
• 有序性：两者军保证有序性。volatile禁止JVM编译器及处理器对指令进行重排序；synchronied关键字不禁止重排序，但通过排他机制保证同步代码块输出结果的正确性不受重排序影响

3、关于阻塞

• volatile不会使线程阻塞；synchronized回使线程进入阻塞

---