双重检验锁方式实现单例模式

双重检验锁方式实现单例模式

引用

CSDN

1.

https://blog.csdn.net/Flying_Fish_roe/article/details/142908772

Java中的单例模式

单例模式（Singleton Pattern）是一种设计模式，它确保一个类在整个程序运行期间只有一个实例，并提供一个全局的访问点。单例模式常用于需要在多个地方共享同一个资源或者需要控制对象创建的场景，例如数据库连接、线程池、配置文件管理等。

单例模式的基本要点

1. 唯一性 ：确保类只有一个实例。
2. 全局访问点 ：提供一个全局的访问方式，让其他类能够获取该实例。
3. 延迟初始化 ：有时需要在第一次使用时才创建实例，避免浪费资源。

单例模式的实现方式

单例模式有多种实现方式，主要包括以下几种：

1. 饿汉式（Eager Initialization） ：在类加载时就创建实例。
2. 懒汉式（Lazy Initialization） ：在第一次需要使用实例时才创建它。
3. 双重检查锁定（Double-Checked Locking） ：一种优化的懒汉式实现，结合了延迟加载和线程安全的特点。
4. 静态内部类 ：利用类加载机制实现线程安全的单例模式。
5. 枚举单例 ：利用枚举实现单例，天生线程安全并且防止反射和序列化漏洞。

双重检查锁定（Double-Checked Locking）方式实现单例模式

双重检查锁定是一种优化的单例模式实现方式，目的是在确保线程安全的同时，减少不必要的同步开销。这个模式的核心思想是：通过检查实例是否已经被创建来避免每次获取实例时都进行同步操作，从而提高性能。

实现步骤

1. 声明私有静态变量 ：持有单例实例的引用，使用volatile关键字修饰以确保内存可见性。
2. 私有构造方法 ：确保类不能被外部实例化。
3. 提供公有的静态方法 ：用于获取单例实例，内部实现双重检查锁定。

以下是一个基于双重检查锁定实现的单例模式的示例：

public class Singleton {
    // 使用volatile确保多线程环境下的可见性和防止指令重排序
    private static volatile Singleton instance;

    // 私有构造方法，防止外部直接实例化
    private Singleton() {
        // 可能的初始化代码
    }

    // 公有静态方法，返回单例实例
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查，避免不必要的同步
            synchronized (Singleton.class) { // 同步块，防止多线程同时进入创建多个实例
                if (instance == null) { // 第二次检查，确保实例尚未创建
                    instance = new Singleton(); // 创建实例
                }
            }
        }
        return instance; // 返回实例
    }
}

关键点解析

1. volatile关键字 ：

• 在声明instance变量时使用volatile是为了防止指令重排序（Instruction Reordering）。这是因为实例化对象的过程并非原子操作，通常包含以下步骤：
  1. 为Singleton分配内存。
  2. 调用Singleton的构造函数，初始化对象。
  3. 将instance引用指向分配的内存地址。
• 如果不使用volatile，步骤2和步骤3可能会被重排序，从而导致在多线程环境中，一个线程看到instance已经指向某个内存地址，但对象还未初始化完成，这可能会引发难以调试的错误。

2. 第一次检查（if (instance == null)） ：

• 目的是避免不必要的同步操作。如果instance已经被创建，直接返回即可，避免进入同步块，提高性能。

3. 同步块（synchronized） ：

• 用于确保在多线程环境下，只有一个线程能够进入同步块并创建实例，从而防止多个线程同时创建多个实例。

4. 第二次检查（if (instance == null)） ：

• 在同步块内进行第二次检查，以确保在进入同步块后实例依然未被创建。如果没有第二次检查，即使多个线程已经通过了第一次检查，仍可能同时创建多个实例。

优点

• 线程安全 ：通过同步和双重检查，确保了线程安全。
• 高效 ：相比每次都同步的懒汉式实现，双重检查锁定只在第一次创建实例时才进行同步，大大减少了同步的开销。
• 延迟加载 ：实例仅在第一次调用getInstance()方法时创建，节省资源。

缺点

• 复杂性 ：相对于其他实现方式，双重检查锁定的实现较为复杂，需要了解volatile关键字的使用和指令重排序的概念。
• 依赖于JVM ：早期的Java版本（Java 5之前）中，JVM对volatile的实现存在问题，可能导致双重检查锁定失效。虽然这一问题在Java 5及以后版本已经解决，但仍需要了解历史背景。

常见问题与解决

1. 指令重排序问题 ：通过使用volatile关键字解决，确保对象的初始化过程不会被重排序。
2. 反射和序列化漏洞 ：即使使用双重检查锁定，反射和序列化仍可能破坏单例模式。可以通过以下方法进一步保护单例：

• 防止反射 ：在构造函数中检查instance是否已被创建，如果已被创建，则抛出异常。
• 防止序列化 ：实现readResolve方法，确保反序列化时返回同一个实例。

private Singleton() {
    if (instance != null) {
        throw new RuntimeException("Use getInstance() method to create");
    }
}

protected Singleton readResolve() {
    return getInstance();
}

总结

双重检查锁定是一种优化的单例模式实现方式，通过减少不必要的同步操作，提高了程序的执行效率，同时也能确保线程安全和延迟加载。尽管它在某些情况下实现较为复杂，但在现代Java环境中（Java 5及以后），这是一个非常有效且常用的单例模式实现方式。

单例模式在实际开发中广泛应用于配置管理、数据库连接管理、日志系统等场景，通过合理的设计和实现，可以确保系统在多线程环境中的正确性和高效性。理解双重检查锁定的机制及其优缺点，有助于开发者编写更健壮的Java程序。