https://juejin.cn/post/6844903778441756680

    1. public class Singleton {
    2.     private static volatile Singleton INSTANCE;  // volatile
    4.     private Singleton() { // private
    5.     }
    6.     /**
    7.      * 双重校验锁
    8.      */
    9.     public static Singleton getInstance() {  
    10.         if (INSTANCE == null) {    // 两次判断
    11.             synchronized (Singleton.class) {
    12.                 if (INSTANCE == null) {
    13.                     INSTANCE = new Singleton();
    14.                 }
    15.             }
    16.         }
    17.         return INSTANCE;
    18.     }
    19. }
    20. ==============
    21. public class Singleton {
    22.     private static Singleton INSTANCE = new Singleton();  // volatile
    24.     private Singleton() { // private
    25.     }
    27.     public static Singleton getInstance() {  
    28.         return INSTANCE;
    29.     }
    30. } 
    31. ==========
    32. public class Singleton { 
    33.     private Singleton(){
    34.     }
    35.       public static Singleton getInstance(){  
    36.         return SingletonHolder.sInstance;  
    37.     }  
    38.     private static class SingletonHolder {  
    39.         private static final Singleton sInstance = new Singleton();  
    40.     }  
    41. }

    如果不加volatile：

    • 给 instance 分配内存
    • 调用Singleton 的构造函数来初始化成员变量
    • 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了） 但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。 我们只需要将 instance 变量声明成 volatile 就可以了。

    Java 里只有 volatile 变量是能实现禁止指令重排的
    synchronized 块里的非原子操作依旧可能发生指令重排

    引用：
    计数器，打印机