/*** 懒汉式 方式6 双重检查锁*/
public class SingletonLazy {// 1、私有构造方法private SingletonLazy(){}// 2、在成员变量位置声明一个静态对象private static volatile SingletonLazy instance; // 关键字volatile：禁止指令重排序，确保绝对安全// 3、对外提供静态方法获取唯一实例public static SingletonLazy getInstance() {if (instance == null) { // 提升性能：第一次判断，若instance不为空，不进入抢锁阶段，直接返回实例synchronized (SingletonLazy.class) {if (instance == null) { // 确保安全：第二次判断，抢到锁后再次判断是否为nullinstance = new SingletonLazy();}}}return instance;}}
1. synchronized (SingletonLazy.class) 是干什么的？
作用： 这是一个互斥锁（排他锁）。
因为 getInstance 是一个 static 方法，它不属于任何对象实例，而是属于类本身。所以需要锁住 SingletonLazy.class 这个类对象。
比喻：
想象 synchronized 花括号 { ... } 包裹的代码块是一个试衣间，而 SingletonLazy.class 是这个试衣间唯一的钥匙。
- 不管外面有多少人（线程）想进去，同一时间只有一个人能拿着钥匙进去。
- 其他人如果没有抢到钥匙，就必须在门口排队等待（Block），直到里面的人出来并归还钥匙。
2. 为什么抢到锁了，还要做第二次判断？
**疑问：“既然线程 A 进去了，线程 B 就进不去，那线程 A 放心大胆地创建不就行了吗？”
答案：为了防止“漏网之鱼”。
模拟一个多线程并发的场景就明白了：
场景还原：
假设有两个线程：线程 A 和 线程 B，同时调用 getInstance()，且此时 instance 为 null。
- 第一步（关键）：
- 线程 A 执行到第 11 行
if (instance == null)，判断为 true（需要创建）。 - 同时，线程 B 也执行到第 11 行，因为它还没被锁住，它看到的
instance也是 null，判断也为 true。 - 结果： A 和 B 都通过了第一层关卡，来到了
synchronized门外。
- 第二步（抢锁）：
- 线程 A 动作快，抢到了锁，进入了
synchronized块内部。 - 线程 B 慢了一步，被挡在门外，进入阻塞（等待）状态。
- 注意： 此时线程 B 已经通过了第一个
if，它只是在等锁，而不是被第一个if挡回去。
- 第三步（A 创建对象）：
- 线程 A 在锁内部，执行
instance = new SingletonLazy();。 - 对象创建完毕，
instance不再是 null。 - 线程 A 释放锁，离开。
- 第四步（B 的灾难）：
- 锁被释放了，线程 B 终于拿到了锁，进入了
synchronized块内部。 - 如果没有第二次判断： 线程 B 会直接执行
new SingletonLazy()。 - 后果： 虽然 A 已经创建了一个对象，但 B 又创建了一个！单例模式失效了，变成了“双例”。
- 第五步（B 的救赎 - 第二次判断）：
- 因为有了第 13 行的
if (instance == null)。 - 线程 B 进门后，虽然它之前在门外看到的是 null，但它进门后再看一眼：发现
instance已经被 A 初始化了（不为 null）。 - 结果： 线程 B 放弃创建，直接退出。
总结
- 第一次判断 (
ifoutside)： 是为了性能。一旦对象创建好了，后面的线程根本不需要排队抢锁，直接拿走对象即可。 - 第二次判断 (
ifinside)： 是为了安全。防止在多线程并发的极端情况下，两个线程同时通过了第一层检查，导致重复创建对象。
补充
为什么instance 变量必须加上 volatile 关键字？。
在 Java 高并发环境下，这段代码不加volatile关键字有一个隐患。
// 必须加 volatile
private static volatile SingletonLazy instance;原因： new SingletonLazy() 这个操作在计算机底层不是原子性的，它分三步：
- 分配内存。
- 初始化对象。
- 将
instance指向这块内存。
如果没有 volatile，CPU 可能会指令重排序（比如变成 1 -> 3 -> 2）。
如果在执行完 1 和 3（此时 instance 已经不为 null，但对象还没初始化好）时，另一个线程来了，它在第一次判断时发现 instance 不为 null，直接拿去用了。结果就是：拿到了一个半成品对象，程序报错。
volatile 的作用就是禁止指令重排序，保证绝对安全。