Java 之 volatile 详解

一、概念
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++ 是一个复合操作,包括三个部分:

  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 步骤 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; 这个指令之后。

你可能感兴趣的:(#,Java,java,jvm,开发语言)