Java 之 volatile 详解

1、概念

volatile 是 Java 中的关键字，是一个变量修饰符，被用来修饰会被不一样线程访问和修改的变量。

2、volatile 做用

1. 可见性

可见性是指多个线程访问同一个变量时，其中一个线程修改了该变量的值，其它线程可以当即看到修改的值。

在 Java 内存模型中，全部的变量都存储在主存中，同时每一个线程都拥有本身的工做线程，用于提升访问速度。线程会从主存中拷贝变量值到本身的工做内存中，而后在本身的工做线程中操做变量，而不是直接操做主存中的变量，因为每一个线程在本身的内存中都有一个变量的拷贝，就会形成变量值不一致的问题。

以下面的代码所示：

测试类：

class VolatileTestObj {

    private String value = null;
    private boolean hasNewValue = false;

    public void put(String value) {
        while (hasNewValue) {
            // 等待，防止重复赋值
        }
        this.value = value;
        hasNewValue = true;
    }

    public String get() {
        while (!hasNewValue) {
            // 等待，防止获取到旧值
        }
        String value = this.value;
        hasNewValue = false;
        return value;
    }
}复制代码

测试代码：

public class VolatileTest {

    public static void main(String... args) {
        VolatileTestObj obj = new VolatileTestObj();
        new Thread(() -> {
            while (true) {
                obj.put("time：" + System.currentTimeMillis());
            }
        }).start();
        new Thread(() -> {
            while (true) {
                System.out.println(obj.get());
            }
        }).start();
    }
}复制代码

以上测试代码中，一个线程进行赋值操做，另外一个线程取值，运行该测试代码能够发现，很容易阻塞在循环等待中。

这是由于写线程写入一个新值，同时将 hasNewValue 置为 true，可是只更新了写线程本身工做线程的缓存值，没有更新主存中的值。而读线程在获取新值是，其工做线程中的 hasNewValue 为 false，会陷入到循环等待中，即便写线程写了新值，读线程也没法获取。由于读线程没有获取都新值，写线程的 hasNewValue 没有被置回 false，因此写线程也会陷入到循环等待中。所以产生了死锁。

使用 volatile 关键字能够解决这个问题，使用 volatile 修饰的变量确保了线程不会将该变量拷贝到本身的工做线程中，全部线程对该变量的操做都是在主存中进行的，因此 volatile 修饰的变量对全部线程可见。

使用 volatile 修饰 hasNewValue，这样在写线程和读线程中都是在主存中操做 hasNewValue 的值，就不会产生死锁。

2. 原子性

volatile 只保证单次读/写操做的原子性，对于多步操做，volatile 不能保证原子性，以下代码所示：

测试类：

class VolatileCounter {

    private volatile int count = 0;

    public void inc() {
        count++;
    }

    public void dec() {
        count--;
    }

    public int get() {
        return count;
    }
}复制代码

测试代码：

public class VolatileTest {

    public static void main(String... args) {
        while (true) {
            VolatileCounter counter = new VolatileCounter();
            Thread thread1 = new Thread(() -> {
                for (int i = 0; i < 50; i++) {
                    counter.inc();
                }
            });
            Thread thread2 = new Thread(() -> {
                for (int i = 0; i < 50; i++) {
                    counter.dec();
                }
            });
            thread1.start();
            thread2.start();
            try {
                thread1.join();
                thread2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("counter = " + counter.get());
        }
    }
}复制代码

运行结果：

...
counter = 0
counter = 0
counter = 0
counter = 0
counter = -21
counter = 0
counter = 0
counter = 0
counter = 0
...复制代码

从运行结果能够看出，绝大部分状况下输出结果为 counter = 0，但也有部分其它结果。由此可知，对于 count++; 和 count--; 这两个操做并不具备原子性。

这是由于 count++ 是一个复合操做，包括三个部分：

1. 读取 count 的值；

2. 对 count 加 1；

3. 将 count 的值写回内存；

volatile 对于这三步操做是没法保证原子性的，因此会出现上述运行结果。

因此，vloatile 并不能解决全部同步的问题

3. 有序性

在 Java 内存模型中，容许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，可是会影响到多线程并发执行的正确性。

volatile 关键字能够禁止指令从新排序，能够保证必定的有序性。

volatile 修饰的变量的有序性有两层含义：

1. 全部在 volatile 修饰的变量写操做以前的写操做，将会对随后该 volatile 修饰的变量读操做以后的语句可见。

2. 禁止 JVM 重排序：volatile 修饰的变量的读写指令不能和其先后的任何指令重排序，其先后的指令可能会被重排序。

3.1 happen-before

happen-before 关系是用来判断是否存在数据竞争、线程是否安全的主要依据，也是指令重排序的依据，保证了多线程下的可见性。

volatile 修饰的变量在读写时会创建 happen-before 关系。

以下面的测试类：

class VolatileOrder {

    int i = 0;
    volatile boolean flag = false;

    public void write() {
        i = 1; // 步骤 1
        flag = true; // 步骤 2
    }

    public String get() {
        if (flag) { // 步骤 3
            System.out.println("i = " + i); // 步骤 4
        }
    }
}复制代码

上面的代码依据 happen-before 原则（关于 happen-before 原则可自行搜索）会创建以下的关系：

• 根据 happen-before 单线程顺序原则会有：步骤 1 happen-before 步骤 二、步骤 3 happen-before 步骤 4；

• 根据 happen-before 的 volatile 原则会有：步骤 2 happen-before 步骤 3；

• 根据 happen-before 的传递性原则会有：步骤 1 happen-before 步骤 4；

因此 步骤 1 对于 步骤 4 是可见的，即变量 i 在多个线程中具备可见性。

这也解释了 volatile 有序性的第一层含义：全部在 volatile 修饰的变量写操做以前的写操做，将会对随后该 volatile 修饰的变量读操做以后的语句可见。

利用这个特性能够优化变量在线程间的可见性，不须要对每一个变量都用 volatile 修饰，只须要用 volatile 修饰一部分变量便可保证其它变量在多线程间也具备可见性。

3.2 禁止 JVM 重排序

对于上述代码，若是变量 flag 没有使用 volatile 修饰，那么步骤 1 和步骤 2 就有可能被 JVM 重排序，就没法获得上述的 happen-before 关系，因此 volatile 修饰的变量禁止 JVM 重排序。

以下代码所示：

class VolatileOrder {

    int a, b, c;
    volatile int d;

    void write() {
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }

    void read() {
        int D = d;
        int A = a;
        int B = b;
        int C = c;
    }
}复制代码

在 write() 方法中：

a = 1;
b = 2;
c = 3;复制代码

JVM 可能会重排序这三个指令，可是这三个指令必定是排在 d = 4; 这个指令以前。

一样的，在 read() 方法中：

int A = a;
int B = b;
int C = c;复制代码

JVM 可能会重排序这三个指令，可是这三个指令必定是排在 int D = d; 这个指令以后。