volatile 关键字
volatile 作用
volatie 用于修饰变量，它有两个作用。
- 它可以保证变量在多线程之间是可见的，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
- 禁止指令重排序。
volatile 保证变量的可见性
先来看一下 volatile 保证变量在线程之间的可见性问题，在下面这段代码中，isContinuePrint共享变量，printThread 这个线程体中使用这个while (isContinuePrint)来判断是否要继续执行。如果在其他线程中将标记修改为 false 的话，printThread会跳出 while 循环吗？
public class PrintString implements Runnable {
private boolean isContinuePrint = true;
@Override
public void run() {
while (isContinuePrint) {
System.out.println(Thread.currentThread().getName() + " print running...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+" end..");
}
public void setContinuePrint(boolean continuePrint) {
isContinuePrint = continuePrint;
}
public static void main(String[] args) {
PrintString printString = new PrintString();
Thread printThread = new Thread(printString);
printThread.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//在主线程停止
printString.setContinuePrint(false);
System.out.println(Thread.currentThread().getName() + " end");
}
}
在大多数执行结果来是可以跳出循环的，但是这里面是有问题的。我们可以将上面的代码简化为以下伪代码
private boolean isContinuePrint = true;
//线程1
while(isContinuePrint){
//噼里啪啦执行
}
//线程2
isContinuePrint = false
线程1先开始执行，然后线程2再执行。在一段时间后，线程2将isContinuePrint设置为 false，这时线程2的isContinuePrint如果还没有来得及写入到主存中，CPU 就去执行线程1，这时线程1得到的值还是true，那么就不会跳出循环了。
我们使用 volatile 在修饰 isContinuePrint 就可以解决这个问题了。
private volatile boolean isContinuePrint = true;
volatile 能保证变量被一个线程2修改后，会立即将数据写入到主存中，并且线程1中缓存的变量无效，这样线程1去读取这个变量时就能得到一个最新的值。
volatile能保证原子性吗？
什么是原子性操作？
对于共享资源一步或者多步的操作是不会被中断执行的，这种操作过程就是原子性操作，将整个操作视为一个整体，这是原子性操作的核心特征。
验证 volatile 不能保证原子性操作
volatile 是不能保证多线程对共享资源操作的原子性的，下面通过一个栗子的证明：
它的执行结果是会是 200 吗？
public class NoAtomicPersonCount implements Runnable {
private int personCount = 0;
public static void main(String[] args) {
NoAtomicPersonCount waiter = new NoAtomicPersonCount();
Thread person1 = new Thread(waiter);
Thread person2 = new Thread(waiter);
person1.start();
person2.start();
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
personCount++;
}
//它的执行结果是会是 200 吗？
System.out.println(Thread.currentThread().getName() + "-人数：" + personCount);
}
}
答案是不一定会是200。因为在多个线程下对
personCount进行累加操作。而 personCount++ 它并不是一个原子性操作，因此在多线程环境下，就会出现数据错误问题。
personCount++ 在内存中的操作过程如下：
-
线程person1读取了personCount的值0，这时线程person1工作内存就保存了personCount的值为0。这时 CPU 的执行权被线程person2抢走了，这时线程person1就阻塞了。 -
线程person2读取主存中的personCount此时值为0，因为线程person1只是读取了personCount，并没有修改这个值，因此不会导致线程person2中的缓存失效，然后线程person2对personCount进行累加然后写入到主存的值为1中。 - 到了
线程person1执行时，由于在第一步中已经将personCount读取到本地内存中，因此不会再去主存中读取了，这时进行累加得到值是personCount的值为 1。 - 此时
线程person1和线程person2操作得到的值都是1，这就出现了线程安全问题。
针对上面的栗子，这里使用一个草图来描述一下为什么 volatile 不能保证原子性。
volatile能保证有序性吗？
在前面介绍 volatile 的作用时，提到的第二个点，禁止指令重排序。
它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
它会强制将对缓存的修改操作立即写入主存；
如果是写操作，它会导致其他CPU中对应的缓存行无效。
这里以 DCL 的单例设计模式来分析 volatile 的有序性问题
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null){//A
synchronized(Singleton.class){//B
if (instance == null)//C
instance = new Singleton();//D
}
}
return instance;
}
}
线程1调用 getInstance() 获取锁，执行到了 D 位置，执行Singleton()对象的创建。-
Singleton()对象的创建按照顺序分为以下3个步骤：- 在内存中分配地址。
- 执行构造函数对对象初始化。
- 将内存空间地址赋值给该引用变量instance。
这里如果 JVM 对指令优化，导致第2步和第3部的执行顺序相反
- 在内存中分配地址。
- 将内存空间地址赋值给该引用变量instance。
- 执行构造函数对对象初始化。
这时线程1先执行
将内存空间地址赋值给该引用变量，但是还没有来得及执行构造函数对对象初始化，CPU 执行权被线程2抢去了。
-
线程2调用 getInstance() 方法执行到 A 位置，这时发现 instance 不为空，此时返回是 instance ，这个 instance 此时还没有执行执行构造函数对对象初始化这一步操作，所以在使用instance时就会出现问题。
解决这个指令重拍序问题，可以给 instance 变量使用 volatile 修饰。
private static volatile Singleton instance = null;
volatile 能保证 Singleton 对象的创建一定是按照以下步骤执行的。
- 在内存中分配地址。
- 执行构造函数对对象初始化。
- 将内存空间地址赋值给该引用变量instance。
总结
本文总结了 volatile 的两个作用，分别是保证共享变量在多线程之间是可见的和禁止指令重排序，并分别用实例来验证了 volatile 的特性。本文是笔者学习之后的总结，方便日后查看学习，有任何不对的地方请指正。
记录于2019年4月14日
