Java 单例模式（Singleton Pattern）

qq_35082497

1102人浏览 · 2025-02-16 17:34:12

qq_35082497 · 2025-02-16 17:34:12 发布

1. 定义

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。单例模式的核心是：限制类的实例化次数为 1，并提供全局访问点来获取该实例。

单例模式通常用于那些需要共享资源或提供全局访问的类，比如配置管理类、数据库连接池等。

2. 适用场景

需要确保类的实例只有一个：例如，配置管理、日志记录、线程池等。
节约资源：某些对象的创建过程非常耗费资源或时间（例如，数据库连接），单例模式可以确保这些资源只被创建一次。
全局共享的状态：当需要多个部分的代码访问同一个实例且共享同一状态时，单例模式是一个很好的选择。

3. 单例模式的种类

懒汉式（Lazy Initialization）：
- 优点：只有在第一次使用时才会创建实例，节省内存。
- 缺点：需要在多线程环境下确保线程安全，通常会导致性能问题。
饿汉式（Eager Initialization）：
- 优点：在类加载时就创建实例，线程安全，简单易实现。
- 缺点：即使没有使用该实例，类加载时也会创建实例，浪费内存。
双重检查锁定（Double-Checked Locking）：
- 结合了懒汉式的延迟加载和饿汉式的线程安全，常用于需要懒加载且高效的多线程环境。
静态内部类（Bill Pugh Singleton）：
- 使用静态内部类来实现单例模式。既能延迟加载，又能确保线程安全，是现代 Java 推荐的实现方式。
枚举式（Enum Singleton）：
- 利用枚举的特性来实现单例，天生保证了线程安全，并且防止了反序列化和反射攻击。

4. 单例模式的实现

1. 懒汉式（线程不安全）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造方法，防止外部实例化
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();  // 第一次调用时才创建实例
        }
        return instance;
    }
}

问题：多线程环境下，可能会出现多个线程同时进入 if (instance == null) 判断，导致创建多个实例。

2. 懒汉式（线程安全，使用 synchronized）

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

问题：synchronized 每次获取实例都要加锁，性能开销较大。

3. 饿汉式（线程安全）

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

优点：实例在类加载时就已经创建，线程安全，简单高效。

缺点：即使实例没有被使用，类加载时就会创建实例，浪费内存。

4. 双重检查锁定（Double-Checked Locking）

public class Singleton {
    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;
    }
}

优点：结合了懒加载和线程安全的优势，性能较好。

缺点：需要确保 instance 变量被声明为 volatile，以防止由于 JVM 的优化导致多线程问题。

5. 静态内部类（Bill Pugh Singleton）

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

优点：线程安全，延迟加载，且实现简单。

原理：SingletonHolder 类是静态内部类，它只有在 getInstance() 方法被调用时才会加载，从而保证了延迟加载。JVM 会保证类的加载是线程安全的。

6. 枚举式（Enum Singleton）

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // 执行某些操作
    }
}

优点：枚举类型天生是线程安全的，且能够防止反序列化和反射攻击，推荐使用。

5. 优缺点

优点：

避免多次实例化：单例模式确保一个类只有一个实例，避免了重复创建对象，节省了资源。
全局访问点：可以通过全局访问点（如 getInstance() 方法）轻松访问该对象。
线程安全：使用适当的同步机制，单例模式能够在多线程环境中保持线程安全。

缺点：

全局状态：单例模式会创建一个全局共享的状态，可能会导致系统中的其他部分与这个全局状态强耦合，降低了模块化和灵活性。
难以测试：单例类通常会在整个应用中处于全局作用域，可能导致单元测试时的困难，尤其是需要模拟或替换单例对象时。
生命周期管理问题：单例的生命周期通常由系统管理，无法通过容器（如 Spring）来灵活控制。

6. 哪些框架使用过单例模式

单例模式在许多流行的框架和库中都有广泛的应用：

Spring 框架：
- Spring 中的 Bean 的作用域是可以配置的，默认情况下，Spring 的 Bean 是单例的。也就是说，Spring 容器中每个 Bean 默认只有一个实例。
Java 的 Runtime 类：
- Java 的 Runtime 类是单例模式的经典应用，它允许获取一个 Runtime 实例，并与之交互来管理 Java 程序的运行环境。Runtime 类通过 getRuntime() 方法提供对唯一实例的访问。
Java 的 Calendar 类：
- Calendar.getInstance() 方法返回一个 Calendar 对象的实例。虽然这个方法并不严格是单例模式，但在某些情况下，Java 系统会使用单例模式来提供一个全局的 Calendar 实例。
Logger 类：
- 很多日志框架，如 Log4j、SLF4J 等，通常会使用单例模式来实现全局日志记录器的实例。通过一个静态方法来获取日志实例，确保全局只有一个日志对象。
Singleton Pattern in Android：
- 在 Android 中，SharedPreferences、SQLiteDatabase 等类也通常采用单例模式来确保每个类只有一个实例，避免不必要的资源浪费和复杂的对象管理。
Hibernate：
- Hibernate 中的 SessionFactory 就是通过单例模式来实现的，SessionFactory 通常是不可变的，并且整个应用中会有且仅有一个实例。
Java Swing：
- 在 Java Swing 库中，很多组件（如 JFileChooser）都实现了单例模式，确保应用中只使用一个文件选择器实例。

7. 总结

单例模式是一个非常常见且有用的设计模式，它确保一个类只有一个实例，并提供了一个全局的访问点。单例模式有多种实现方式，每种方式在性能、线程安全等方面有所不同。根据不同的应用场景，可以选择适合的实现方式。在多线程环境中，静态内部类单例模式（Bill Pugh Singleton）和枚举单例模式通常被认为是最优的实现方式。

在实际开发中，单例模式有着广泛的应用，尤其是在配置管理、资源共享、日志记录等领域，许多流行的框架（如 Spring、Hibernate）都在内部使用了单例模式。