Java 双重检查锁定

原创已于 2025-09-17 11:24:02 修改 · 577 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2025-09-11 12:05:59 首次发布

单例模式 (Singleton Pattern)

确保一个类只有一个实例，并提供一个全局访问点。

核心思想：

私有化构造函数，防止外部直接用 new 创建对象。
提供一个公有的静态方法，用于获取这个唯一的实例。

应用场景：

数据库连接池、日志记录器、配置管理器等。

public class Singleton {

// 1. 私有化构造函数，防止外部new实例
private Singleton() {
// 防止通过反射破坏单例
if (Holder.INSTANCE != null) {
throw new RuntimeException("Do not create by reflection!");
}
}

// 2. 提供一个公共的静态方法，用于获取实例
public static Singleton getInstance() {
return Holder.INSTANCE;
}

// 3. 定义静态内部类，其静态属性指向唯一实例
private static class Holder {
private static final Singleton INSTANCE = new Singleton();
}
}

懒加载（Lazy Loading）：不同于饿汉式，这个方式只有在调用 getInstance() 方法时，JVM才会加载 Holder 类并初始化 INSTANCE，避免了不必要的资源消耗。
线程安全：类的静态属性初始化是在类加载阶段完成的，而JVM会保证类加载过程的线程安全性，所以这种方式是天然线程安全的，无需synchronized关键字，性能很高。
代码简洁：实现起来非常简洁和优雅。

public class DatabaseConnection {
// 1. 使用 volatile 关键字保证实例的可见性
private static volatile DatabaseConnection instance;

// 2. 私有化构造函数
private DatabaseConnection() {
// 防止通过反射创建多个实例
if (instance != null) {
throw new RuntimeException("请通过 getInstance() 方法获取实例。");
}
}

// 3. 公有静态方法，提供全局访问点
public static DatabaseConnection getInstance() {
// 第一次检查，避免不必要的同步开销
if (instance == null) {
// 同步块，确保只有一个线程能进入
synchronized (DatabaseConnection.class) {
// 第二次检查，防止多个线程同时创建实例
if (instance == null) {
instance = new DatabaseConnection();
}
}
}
return instance;
}
}

优点：懒加载，线程安全，且只有在初始化时才加锁，性能较好。
缺点：代码稍复杂，需要写对volatile关键字，否则在高并发下可能出问题。

1.当服务第一次尝试获取instance时进入这个模块 //（第一次检查，避免不必要的同步开销）这个意思是有实例直接返回吗同步开销指的是什么

2. （// 同步块，确保只有一个线程能进入）这里同步了整个类也就是只有一个线程能进入访问这个方法吗

3. （// 第二次检查，防止多个线程同时创建实例）这是防止已经有多个线程进入到这里吗可是任何一个线程都会执行synchronized后才进来这里是为啥再确认呢

1. “第一次检查，避免不必要的同步开销”

你的理解是正确的。这句话的意思是：如果有实例了，就直接返回，不需要进行任何同步操作。

同步开销：在多线程环境中，synchronized 关键字会引入性能开销。它会让线程排队等待获取锁，这涉及到线程的上下文切换和资源的竞争。这个过程会消耗 CPU 时间。

这段代码的目的是在绝大多数情况下（即 instance 已经创建），让线程可以直接跳过同步块，避免不必要的性能损耗，从而提高并发效率。只有当 instance 为 null 时，才需要进入同步块进行线程安全的创建。

2. “同步块，确保只有一个线程能进入”

你的理解也基本正确，但需要更精确地描述。

同步范围：synchronized (DatabaseConnection.class) 锁定的不是整个方法，而是整个 DatabaseConnection 类。这意味着在任何时候，只有一个线程可以执行这个同步块内部的代码。
其他线程：当一个线程 A 进入同步块时，其他试图进入该同步块的线程 B、C... 都会被阻塞，直到线程 A 执行完同步块内的代码并释放锁。

所以，这里的同步块是为了保证实例创建的原子性，防止多个线程同时执行 instance = new DatabaseConnection(); 这行代码。

3. “第二次检查，防止多个线程同时创建实例”

这是一个至关重要的步骤，也是双重检查锁定的精髓所在。

为什么需要第二次检查？ 想象一下这样一个场景：
1. 线程 A 和线程 B 同时检查 if (instance == null)，发现实例都为 null，于是它们都准备进入同步块。
2. 线程 A 率先获取了锁，进入同步块。
3. 线程 A 再次检查 if (instance == null)，条件成立，然后执行 instance = new DatabaseConnection();。此时，实例已经被创建了。
4. 线程 A 退出同步块，释放了锁。
5. 线程 B 终于获取了锁，进入同步块。
如果没有第二次检查，线程 B 就会再次执行 instance = new DatabaseConnection();，从而创建第二个实例。这违背了单例模式的初衷。
有了第二次检查，线程 B 进入同步块后，会再次执行 if (instance == null)。此时，它发现 instance 已经被线程 A 创建了，所以条件不成立，线程 B 就会跳过创建实例的代码，直接返回已有的实例。

因此，第二次检查是防止在并发环境下，多个线程都通过第一次检查后，创建出多个实例。它确保了在任何情况下，new DatabaseConnection() 这行代码只会被执行一次。

“如何破坏单例？怎么防止？”

答：“常见的破坏方式有两种：

反射：通过反射调用私有构造函数创建新实例。
- 防止：像我刚才在构造函数里写的那样，判断如果 INSTANCE 已不为null，则抛出异常。
反序列化：将一个序列化的单例对象反序列化后，会得到一个新对象。
- 防止：在类中实现一个 readResolve() 方法，并返回唯一的实例。
java
```
// 在Singleton类中添加此方法，可防止反序列化破坏
private Object readResolve() {
    return Holder.INSTANCE;
}
```