Java关键字volatile的使用 – 滴水技术日志

volatile是在多线程编程中经常需要用到的一个关键字，很多地方都有关于这个关键字的用法说明，但一直看得一知半解，这里汇集一下网上收集到的各种资料，辅以示例代码来说明，便于理解。

Java内存模型与线程

多任务和高并发是衡量一台计算机处理器的能力重要指标之一。一般衡量一个服务器性能的高低好坏，使用每秒事务处理数（Transactions Per Second，TPS）这个指标比较能说明问题，它代表着一秒内服务器平均能响应的请求数，而TPS值与程序的并发能力有着非常密切的关系。

硬件的效率与一致性

由于计算机的存储设备与处理器的运算能力之间有几个数量级的差距，所以现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高速缓存（cache）来作为内存与处理器之间的缓冲：将运算需要使用到的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中没这样处理器就无需等待缓慢的内存读写了。基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是引入了一个新的问题：缓存一致性（Cache Coherence）。在多处理器系统中，每个处理器都有自己的高速缓存，而他们又共享同一主存，如下图所示：多个处理器运算任务都涉及同一块主存，需要一种协议可以保障数据的一致性，这类协议有MSI、MESI、MOSI及Dragon Protocol等。Java虚拟机内存模型中定义的内存访问操作与硬件的缓存访问操作是具有可比性的，后续将介绍Java内存模型。

除此之外，为了使得处理器内部的运算单元能竟可能被充分利用，处理器可能会对输入代码进行乱序执行（Out-Of-Order Execution）优化，处理器会在计算之后将对乱序执行的代码进行结果重组，保证结果准确性。与处理器的乱序执行优化类似，Java虚拟机的即时编译器中也有类似的指令重排序（Instruction Recorder）优化。

if (doSomething("上车")) {       
   doSomethingElse("刷卡") 
 }

计算机实际执行时，可能先刷卡，再判断是否上车，如果上车了，就使用刷卡的结果，如果没上车，就抛弃掉刷卡的结果。

Java 内存模型

JMM（Java Memory Model）试图屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果。在JDK1.5后，Java内存模型已经成熟和完善。

主内存与工作内存

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样底层细节。此处的变量与Java编程时所说的变量不一样，指包括了实例字段、静态字段和构成数组对象的元素，但是不包括局部变量与方法参数，后者是线程私有的，不会被共享。

Java内存模型中规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存（可以与前面将的处理器的高速缓存类比），线程的工作内存中保存了该线程使用到的变量到主内存副本拷贝，线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来完成，线程、主内存和工作内存的交互关系如下图所示，和上图很类似。

内存间交互操作

一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存之类的实现细节，JMM定义了一下八种操作来完成：

lock（锁定）：作用域主内存的变量，它把一个变量标识为一条线程独占的状态；
unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
read（读取）：作用于主内存变量，它变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中；
use（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。也就是read和load之间，store和write之间是可以插入其他指令的，如对主内存中的变量a、b进行访问时，可能的顺序是read a，read b，load b， load a。Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

不允许read和load、store和write操作之一单独出现，如不允许从主内存读取了但工作内存不接受
不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
一个变量在同一时刻只允许一条线程对其进行lock操作，lock和unlock必须成对出现
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

对于volatile型变量的特殊规则

当一个变量被定义成volatile之后，它将具备两种特性，第一是保证此变量对所有线程的可见性，即当一条线程修改了这个变量的值，新值对于其他线程来说是立即得知的。

由于volatile变量只能保证可见性，在不符合以下两条规则的运算场景中，我们仍然要通过加锁来保证原子性。

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

volatile变量的第二个语义是禁止指令重排序优化。

编译器只保证程序执行结果与源代码相同，却不保证实际指令的顺序与源代码相同。这在单线程看起来没什么问题，然而一旦引入多线程，这种乱序就可能导致严重问题。volatile关键字就可以从语义上解决这个问题。

例如，考虑下面的事件序列：

线程A发现变量没有被初始化, 然后它获取锁并开始变量的初始化。
由于某些编程语言的语义，编译器生成的代码允许在线程A执行完变量的初始化之前，更新变量并将其指向部分初始化的对象。
线程B发现共享变量已经被初始化，并返回变量。由于线程B确信变量已被初始化，它没有获取锁。如果在A完成初始化之前共享变量对B可见（这是由于A没有完成初始化或者因为一些初始化的值还没有穿过B使用的内存(缓存一致性)），程序很可能会崩溃。

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

Symantec JIT 编译 singletons[i].reference = new Singleton(); 这段代码时，如果不加volatile关键词，会生成如下字节码：

; allocate space for  Singleton, return result in eax 
0206106A   mov         eax,0F97E78h 
0206106F   call        01F6B210                  

; EBP is &singletons[i].reference, store the unconstructed object here. 
02061074   mov         dword ptr [ebp],eax  
            
; dereference the handle to get the raw pointer 
02061077   mov         ecx,dword ptr [eax] 

; Next 4 lines are Singleton's inlined constructor 
02061079   mov         dword ptr [ecx],100h      
0206107F   mov         dword ptr [ecx+4],200h 
02061086   mov         dword ptr [ecx+8],400h
0206108D   mov         dword ptr [ecx+0Ch],0F84030h

可以看到，在执行Singleton的构造函数之前，Singleton的新实例就被赋值给了singletons[i].reference，这在Java内存模型中是完全合法的。

对于long和double型变量的特殊规则

JVM规范允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行。但是各种虚拟机实现几乎把64位数据的读写作为原子操作来对待(如果分两次来操作，极端情况下得到的结果就会很诡异)

原子性、可见性和有序性

原子性（Atomicity）：大致认为基本数据类型的访问读写是具备原子性的。JMM提供lock和unlock保证原子性，对应代码中的synchronized关键字
可见性（Visibility）：当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。volatile保证新值能立即同步到主内存，以及每次使用前立即从主内存刷新。除了volatile外，synchronized和final两个关键字也能实现可见性，其中同步块是有lock和unlock机制决定的，而final关键字一旦初始化完成，其他线程就能看见final字段的值
有序性（Ordering）：如果在本线程内观察，所有的操作都是有序的；如果在一个线程内观察另一个线程，所有操作都是无序的。Java提供了volatile和synchronized来听歌关键字来保证线程之间操作的有序性。

先行发生原则( happens-before )

先行发生原则：如果操作A先发生于操作B，操作A产生的影响能被操作B观察到，“影响”包括：修改了内存中共享变量的值、发送了消息、调用了方法。

程序次序规则：写在程序签名的操作先行发生于书写在后面的操作
管程锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作
volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量的读操作
线程启动规则：Thread对象的start方法先行发生于此线程的每一个动作
线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测
线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
对象终结规则：一个对象初始化完成先行发生于它的finalize方法的开始
传递性：如果操作A先于操作B，操作B先行于操作C，那么操作A先行发生于操作C

来看一段代码：

public class PrintString implements Runnable{
    private boolean isRunnning = true;

    @Override
    public void run() {
        System.out.println("Thread begin: "+Thread.currentThread().getName());
        while (isRunnning == true){
        }
        System.out.println("Thread end: "+Thread.currentThread().getName());
    }

    public boolean isRunnning() {
        return isRunnning;
    }

    public void setRunnning(boolean runnning) {
        isRunnning = runnning;
    }

    public static void main(String[] args) throws InterruptedException {
        PrintString printString = new PrintString();
        Thread thread = new Thread(printString,"Thread-A");
        thread.start();
        Thread.sleep(1000);
        printString.setRunnning(false);
        System.out.println(" 我要停止它！" + Thread.currentThread().getName());
    }
}

JVM 有 Client 和 Server 两种模式，我们可以通过运行：java -version 来查看 jvm 默认工作在什么模式。我们在 IDE 中把 JVM 设置为在 Server 服务器的环境中，具体操作只需配置运行参数为 -server。然后启动程序，打印结果：

Thread begin: Thread-A
我要停止它！main

代码 System.out.println(“Thread end: “+Thread.currentThread().getName()); 从未被执行。

是什么样的原因造成将 JVM 设置为 -server 就出现死循环呢？

在启动 thread 线程时，变量 boolean isContinuePrint = true; 存在于公共堆栈及线程的私有堆栈中。在 JVM 设置为 -server 模式时为了线程运行的效率，线程一直在私有堆栈中取得 isRunning 的值是 true。而代码 thread.setRunning(false); 虽然被执行，更新的却是公共堆栈中的 isRunning 变量值 false，所以一直就是死循环的状态。

将代码更改如下：

volatile private boolean isRunnning = true;

再次运行：

Thread begin: Thread-A
我要停止它！main
Thread end: Thread-A

通过使用 volatile 关键字，强制的从公共内存中读取变量的值。

到此基本上了解 volatile的使用了，再来看一个有趣的事情：

public class Test {
    private boolean isRunnning = true;

    public static void main(String[] args) throws Exception {
        PrintString printString = new PrintString();
        Thread thread = new Thread(printString,"Thread-A");
        thread.start();
        Thread.sleep(1000);
        System.out.println(" 我要停止它！" + Thread.currentThread().getName());
        printString.setRunnning(false);
    }

    public boolean isRunnning() {
        return isRunnning;
    }

    public void setRunnning(boolean runnning) {
        isRunnning = runnning;
    }
}

class PrintString implements Runnable{
    private volatile Test test = new Test();

    @Override
    public void run() {
        System.out.println("Thread begin: "+Thread.currentThread().getName());
        while (test.isRunnning()){
        }
        System.out.println("Thread end: "+Thread.currentThread().getName());
    }

    public void setRunnning(boolean runnning) {
        test.setRunnning(runnning);
    }

    public void setTest(Test test) {
        this.test = test;
    }
}

Test 里面的isRunnning 没加volatile 关键字，但PrintString 里面的test 变量加了，程序能正常结束，如果都不加 volatile ，程序会死循环，JVM在缓存变量时，会把变量相关的引用变量一起缓存，但对于 volatile 修饰的变量，所有相关的引用变量都不再缓。如果把 volatile 移到 Test 里面的isRunnning 变量上去，程序也能正常结束，说明JVM对所有指定了变量的

public class Test {
    private volatile boolean isRunnning = true;

    public static void main(String[] args) throws Exception {
        PrintString printString = new PrintString();
        Thread thread = new Thread(printString,"Thread-A");
        thread.start();
        Thread.sleep(1000);
        System.out.println(" 我要停止它！" + Thread.currentThread().getName());
        Test test = new Test();
        test.setRunnning(false);
        printString.setTest(test);
    }

    public boolean isRunnning() {
        return isRunnning;
    }

    public void setRunnning(boolean runnning) {
        isRunnning = runnning;
    }
}

class PrintString implements Runnable{
    private Test test = new Test();

    @Override
    public void run() {
        System.out.println("Thread begin: "+Thread.currentThread().getName());
        while (test.isRunnning()){
        }
        System.out.println("Thread end: "+Thread.currentThread().getName());
    }

    public void setRunnning(boolean runnning) {
        test.setRunnning(runnning);
    }

    public void setTest(Test test) {
        this.test = test;
    }
}

虽然test 没有用 volatile 修饰，程序也能正常结束，去掉isRunnning 的volatile ，会出现死循环，说明JVM去拿一个 volatile 的内部变量时，不管外部变量是否用 volatile 修饰，都会去主存中找到最新的外部变量，然后再去找最新的内部变量。

总之为了安全考虑，只要是可能会多线程同时读写的变量，最好都加上 volatile。

参考文章：