一、概念

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

二、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++ 是一个复合操作，包括三个部分：

读取 count 的值；
对 count 加 1；
将 count 的值写回内存；

volatile 对于这三步操作是无法保证原子性的，所以会出现上述运行结果。

所以，vloatile 并不能解决所有同步的问题

3. 有序性

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

volatile 关键字可以禁止指令重新排序，可以保证一定的有序性。

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

所有在 volatile 修饰的变量写操作之前的写操作，将会对随后该 volatile 修饰的变量读操作之后的语句可见。
禁止 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 步骤 2、步骤 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; 这个指令之后。