单例模式的实现办法有很多种，如饿汉模式、懒汉模式、动态外部类和枚举等，当面试官问到“为什么双重效验锁要加volatile？”时，那么他指的是为什么懒汉模式中的公有变量要加 volatile？
懒汉模式指的是对象的创立是懒加载的形式，并不是在程序启动时就创建对象，而是第一次被真正应用时才创建对象。
要解释为什么要加 volatile？咱们先来看懒汉模式的具体实现代码：
public class Singleton { // 1.避免内部间接 new 对象毁坏单例模式 private Singleton() {} // 2.通过公有变量保留单例对象【增加了 volatile 润饰】 private static volatile Singleton instance = null; // 3.提供公共获取单例对象的办法 public static Singleton getInstance() { if (instance == null) { // 第 1 次效验 synchronized (Singleton.class) { if (instance == null) { // 第 2 次效验 instance = new Singleton(); } } } return instance; }}从上述代码能够看出，为了保障线程平安和高性能，代码中应用了两次 if 和 synchronized 来保障程序的执行。那既然曾经有 synchronized 来保障线程平安了，为什么还要给变量加 volatile 呢？
在解释这个问题之前，咱们先要搞懂一个前置常识：volatile 有什么用呢？
1.volatile 作用
volatile 有两个次要的作用，第一，解决内存可见性问题，第二，避免指令重排序。
1.1 内存可见性问题
所谓内存可见性问题，指的是多个线程同时操作一个变量，其中某个线程批改了变量的值之后，其余线程感知不到变量的批改，这就是内存可见性问题。
而应用 volatile 就能够解决内存可见性问题，比方以下代码，当没有增加 volatile 时，它的实现如下：
private static boolean flag = false;public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { @Override public void run() { // 如果 flag 变量为 true 就终止执行 while (!flag) { } System.out.println("终止执行"); } }); t1.start(); // 1s 之后将 flag 变量的值批改为 true Thread t2 = new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("设置 flag 变量的值为 true！"); flag = true; } }); t2.start();}以上程序的执行后果如下：
然而，以上程序执行了 N 久之后，仍然没有完结执行，这阐明线程 2 在批改了 flag 变量之后，线程 1 基本没有感知到变量的批改。
那么接下来，咱们尝试给 flag 加上 volatile，实现代码如下：
public class volatileTest { private static volatile boolean flag = false; public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { @Override public void run() { // 如果 flag 变量为 true 就终止执行 while (!flag) { } System.out.println("终止执行"); } }); t1.start(); // 1s 之后将 flag 变量的值批改为 true Thread t2 = new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("设置 flag 变量的值为 true！"); flag = true; } }); t2.start(); }}以上程序的执行后果如下：
从上述执行后果咱们能够看出，应用 volatile 之后就能够解决程序中的内存可见性问题了。
1.2 避免指令重排序
指令重排序是指在程序执行过程中，编译器或 JVM 经常会对指令进行从新排序，已进步程序的执行性能。
指令重排序的设计初衷的确很好，在单线程中也能施展很棒的作用，然而在多线程中，应用指令重排序就可能会导致线程平安问题了。
所谓线程平安问题是指程序的执行后果，和咱们的预期不相符。比方咱们预期的正确后果是 0，但程序的执行后果却是 1，那么这就是线程平安问题。
而应用 volatile 能够禁止指令重排序，从而保障程序在多线程运行时可能正确执行。
2.为什么要用 volatile？
回到主题，咱们在单例模式中应用 volatile，次要是应用 volatile 能够禁止指令重排序，从而保障程序的失常运行。这里可能会有读者提出疑难，不是曾经应用了 synchronized 来保障线程平安吗？那为什么还要再加 volatile 呢？看上面的代码：
public class Singleton { private Singleton() {} // 应用 volatile 禁止指令重排序 private static volatile Singleton instance = null; public static Singleton getInstance() { if (instance == null) { // ① synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); // ② } } } return instance; }}留神察看上述代码，我标记了第 ① 处和第 ② 处的两行代码。给公有变量加 volatile 次要是为了避免第 ② 处执行时，也就是“instance = new Singleton()”执行时的指令重排序的，这行代码看似只是一个创建对象的过程，然而它的理论执行却分为以下 3 步：
- 创立内存空间。
- 在内存空间中初始化对象 Singleton。
- 将内存地址赋值给 instance 对象（执行了此步骤，instance 就不等于 null 了）。
试想一下，如果不加 volatile，那么线程 1 在执行到上述代码的第 ② 处时就可能会执行指令重排序，将本来是 1、2、3 的执行程序，重排为 1、3、2。然而非凡状况下，线程 1 在执行完第 3 步之后，如果来了线程 2 执行到上述代码的第 ① 处，判断 instance 对象曾经不为 null，但此时线程 1 还未将对象实例化完，那么线程 2 将会失去一个被实例化“一半”的对象，从而导致程序执行出错，这就是为什么要给公有变量增加 volatile 的起因了。
小结
应用 volatile 能够解决内存可见性问题和避免指令重排序，咱们在单例模式中应用 volatile 次要是应用 volatile 的后一个个性（避免指令重排序），从而防止多线程执行的状况下，因为指令重排序而导致某些线程失去一个未被齐全实例化的对象，从而导致程序执行出错的状况。
本文已收录至《Java面试突击》，专一 Java 面试 100 年，查看更多：www.javacn.site