16-Java多线程、volatile关键字

volatile关键字

• 能够被多个线程访问到的变量称之为共享变量，Java中共享变量大多存在于堆中。JMM规定所有的变量都存在主存中，但每个线程都有自己的工作内存，线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作，并且每个线程不能访问其他线程的工作内存。因此就可能存在一个线程修改了共享变量之后，另一个线程不能立刻感知，导致出现线程安全问题。volatile提供了轻量级的线程同步机制，可以保证一个线程修改之后，另一个线程可以立刻感知到，也就是所谓的可见性。

• 共享变量线程安全的条件

原子性：即对一个变量的修改是原子的，不可打断的。
可见性：在多线程环境下，某个共享变量如果被其中一个线程给修改了，其他线程能够立即知道这个共享变量已经被
修改了，当其他线程要读取这个变量的时候，会去内存中读取，而不是从自己的工作空间中读取。

• 由此我们看到volatile并不满足线程安全的所有条件，只满足可见性，因此volatile并不是线程安全的。

一、作用

• 先总的看一下 volatile 的语义作用

2.1 可见性

• 保证可见性。多线程环境下，保证一个线程对变量的修改对另一个线程立刻可见。当一个线程修改volatile变量后它会立即被更新到主内存中，并且该写操作会导致其他线程中该变量的缓存失效，由此保证可见性。

2.2 有序性

• 禁止指令重排。这个话题引申的比较多，涉及到编译后字节码在执行时的重排序的问题，在后面解读；

二、线程不安全

• volatile 修饰的变量是线程不安全的，因为不满足原子性，这点老生常谈了；volatile提供了轻量级的线程同步机制，但是并不能保证线程安全，被volatile修饰的变量，只满足可见性，但不满足原子性。

比如线程A和B同时不断的对变量val进行修改，在主内存中原始值为0，线程A读取后执行a+=10的操作，这个操作不是原子的，再执行+10之
后，A线程挂起，此时还未写回主内存，线程B读取主内存执行a+=20的操作，此后A将结果a=10写回主内存，但是对于B来说，只有在加载a的
时候才能立即看到主内存中的值，此时并不会去主内存加载，因此对B线程来说，计算后的结果为20，然后写回主存a就是20，而不是预想
的30，此处细节可以参考Java内存模型中的指令细分。

线程将变量从主存加载到工作内存并写回主存有read->load->use->assign->store->write一共6步。在上面的例子中，如果一个线程A读取了
变量val，并加载，然后到了use这个阶段，此时另一个线程B修改了主存中的变量，A是感知不到的。从编译后的字节码来看，对一个变量的自
增操作也分为多个指令，而volatile只能保证你获取到这个变量时是主存中最新的值，但是在获取指令后面，你需要对其进行自增自增或者其
他操作指令，后面指令阶段过程中如果主存中val变化线程A是感知不到的。

其中最后一步jvm让这个最新的变量的值在所有线程可见，也就是最后一步让所有的CPU内核都获得了最新的值，但中间的几步（从Load到Store）是
不安全的，中间如果其他的CPU修改了值将会丢失。

• 验证：如下10个线程对一个变量各种自增1000次，期望应该是10000，但是每次结果都不一样，说明了线程不安全性。

public class VolatileTest {

    public volatile int inc = 0;

    public void increase() {
        inc++;
    }

    public static void main(String[] args) {
        final VolatileTest test = new VolatileTest();
        for (int i = 0; i < 10; i++) {
            new Thread() {
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        test.increase();
                    }
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                ;
            }.start();
        }

        try {
            //保证前面的线程都执行完
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      
        System.out.println(test.inc);
    }
}

• 前面的文字是我看到的一种理解，但是实际上在参考文章[4]中给出了文字解释也非常合理，摘抄如下：(参考文章[4]和[5]非常好的解释了volatile的原理，非常推荐认真阅读)

例如你让一个volatile的integer自增（i++），其实要分成3步：1）读取volatile变量值到local； 2）增加变量的值；3）把local的值写回，让
其它的线程可见。这3步的jvm指令为：

mov    0xc(%r10),%r8d ; Load
inc    %r8d           ; Increment
mov    %r8d,0xc(%r10) ; Store
lock addl $0x0,(%rsp) ; StoreLoad Barrier

从Load到store到内存屏障，一共4步，其中最后一步jvm让这个最新的变量的值在所有线程可见，也就是最后一步让所有的CPU内核都获得了最新的
值，但中间的几步（从Load到Store）是不安全的，中间如果其他的CPU修改了值将会丢失。

三、volatile应用场景

• 运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值，变量不需要与其他状态变量共同参与不变约束，不适用于 getAndOperate 的场景。
• 简单来说：适用于读多写少的场景，

四、底层原理

volatile是如何保证可见性和指令不重排？

• 保证可见性：线程对volatile变量执行写操作后，该变量会立即被更新到主内存中，并且该写操作会导致其他线程中该变量的缓存失效，由此保证可见性。
• 禁止指令重排：volatile修饰的变量，禁止其指令重排序

4.1 关于指令重排

指令重排是在执行程序时为了提高性能的手段，编译器和处理器通常会对指令做重排序，具体包括2类：


编译器重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
处理器重排序。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。


单线程环境下指令重排序没有影响，它不会影响程序的运行结果，这是重排的保证，由此Cpu或者编译器通
过指令重排来提高效率，它会保证这种重排在单线程下不会影响结果的正确性。但是在多线程下则有可能影
响程序的正确性，有些时候我们期望特定的代码不会被重排序，使用volatile就能保证其修饰的变量不被重
排序。那么JVM是如何禁止volatile变量重排序的呢？

• 关于指令重排，典型的是DCL写法的单例模式

4.2 内存屏障

• 关于内存屏障：内存屏障是一个CPU指令，基本上，它是这样一条指令： a) 确保一些特定操作执行的顺序； b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。插入一个内存屏障，相当于告诉CPU和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。

在JVM底层volatile是采用"内存屏障"来实现。加入volatile关键字的汇编代码比没有volatile关键字时所生成的汇编代码会多出一个lock前缀指令，lock前缀指令实际上相当于一个内存屏障（也称内存栅栏），内存屏障会提供3个功能：

• 1.强制将对缓存的修改操作立即写入主存；
• 2.如果是写操作，它会导致其他CPU中对应的缓存行无效；
• 3.它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

这三点是保证 volatile 可见性和禁止指令重排的关键；

• 下面是一个 volatile 变量自增操作编译后的汇编指令，从中可以看到，volatile变量的操作分为四个指令步骤，最后一个是添加了StoreLoad Barrier内存屏障，这个屏障保证Store操作后，其值立刻对其他线程CPU可见，但是前面几个步骤不是原子的，同时屏障也保证前面的操作和后面的操作不能重排序，这里同时解释了volatile的两大特性；

mov    0xc(%r10),%r8d ; Load
inc    %r8d           ; Increment
mov    %r8d,0xc(%r10) ; Store
lock addl $0x0,(%rsp) ; StoreLoad Barrier

参考

• [1] 彻底搞懂volatile关键字
• [2] [深入理解Java虚拟机第12章]
• [3] 深入分析 volatile 的实现原理
• [4] 不得不提的volatile及指令重排序(happen-before)
• [5] 精确解释java的volatile之可见性、原子性、有序性（通过汇编语言）
• [6] 为什么volatile不能保证原子性而Atomic可以？