【设计模式】2.深入理解 Java 中的单例模式

深入理解 Java 中的单例模式

单例模式（Singleton Pattern） 是最常见的设计模式之一，它保证在整个应用程序的生命周期中，某个类只有一个实例存在，并且提供一个全局访问点。单例模式适合那些需要在系统中被频繁访问且只需一个实例的对象，例如日志类、配置管理类、数据库连接池等。

一、单例模式的核心思想

• 唯一性：类只有一个实例存在，所有调用者都共享这个实例。
• 全局访问：提供一个全局的访问点，任何地方都可以通过这个访问点获取该实例。

二、单例模式的实现方式

Java 中实现单例模式的方式有多种，最常用的几种方式如下：

1. 饿汉式（Eager Initialization）

饿汉式是在类加载的时候就初始化单例对象。这种方式非常简单，但也存在一定的缺陷，如果单例类占用资源较大，并且不一定会被使用到，那么这种初始化方式可能会浪费资源。

代码实现：

public class Singleton {
    // 在类加载时就实例化对象
    private static final Singleton INSTANCE = new Singleton();

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

    // 提供一个全局访问点
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

优点：

• 实现简单，类加载时初始化，避免线程同步问题。

缺点：

• 如果单例类较大，且程序中未使用该实例，会造成内存浪费。

2. 懒汉式（Lazy Initialization）

懒汉式只有在需要时才会创建单例实例。这种方式可以避免饿汉式的资源浪费问题，但在多线程环境下，可能会引发线程安全问题。

代码实现：

public class Singleton {
    // 先不创建实例
    private static Singleton instance;

    // 私有构造方法
    private Singleton() {}

    // 提供全局访问点，第一次调用时创建实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：

• 延迟实例化，节省资源。

缺点：

• 在多线程环境下，如果两个线程同时访问 getInstance() 方法，可能会导致多个实例被创建。

3. 线程安全的懒汉式

为了在多线程环境中实现安全的单例模式，可以对 getInstance() 方法加锁，使其在并发访问时保持同步，确保实例化时线程安全。

代码实现（同步方法）：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    // 使用 synchronized 关键字，确保线程安全
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：

• 解决了线程安全问题。

缺点：

• 每次调用 getInstance() 方法都会进行同步，导致性能损耗。

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;
    }
}

优点：

• 只有在实例未创建时才会加锁，减少了同步的性能开销。

缺点：

• 代码稍复杂，尤其是在多线程环境下需要处理 volatile 关键字，确保可见性。

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

静态内部类方式是一种巧妙的实现方式，利用了 Java 的类加载机制，只有在调用 getInstance() 方法时，才会加载静态内部类并创建单例对象。它既实现了懒加载，又保证了线程安全。

代码实现：

public class Singleton {
    private Singleton() {}

    // 静态内部类，只有在第一次调用 getInstance() 时才会加载
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

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

优点：

• 实现简单，懒加载，且线程安全。

缺点：

• 无明显缺点，被认为是单例模式的最佳实践之一。

6. 枚举单例（Enum Singleton）

枚举单例是由 Joshua Bloch 在《Effective Java》一书中推荐的方式。使用枚举不仅能够防止反序列化破坏单例，而且本身也是线程安全的。

代码实现：

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("Do something");
    }
}

优点：

• 枚举天生就是单例模式，线程安全。
• 防止通过反序列化或反射破坏单例。

缺点：

• 使用枚举的方式会稍显不灵活，因为它无法进行延迟加载（但很多情况下枚举方式是最佳选择）。

三、单例模式的注意事项

• 线程安全：在多线程环境中，懒汉式单例可能导致创建多个实例，因此需要使用同步、双重检查锁或静态内部类等方式确保线程安全。
• 序列化问题：普通单例模式在序列化时可能会被破坏，导致多个实例存在。可以通过实现 readResolve() 方法来防止此问题。枚举单例天生防止反序列化问题。

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

• 反射问题：通过反射可以绕过构造器的私有权限，从而创建多个实例。可以通过在构造方法中进行防御性判断来防止此问题。

private Singleton() {
    if (instance != null) {
        throw new IllegalStateException("Already initialized");
    }
}

四、单例模式的应用场景

1. 全局配置类：比如应用程序中的配置文件加载类，全局只需一个实例，保证配置文件统一且能被多个模块共享。
2. 日志管理：日志系统通常需要全局唯一实例，以便各个模块可以使用统一的日志处理方式。
3. 数据库连接池：保证同一时刻只有一个连接池实例，多个模块共享数据库连接资源。
4. 线程池：应用程序中创建线程的开销很大，使用单例模式可以保证一个全局线程池。

五、总结

单例模式在 Java 开发中非常常用，它能够确保系统中某个类只有一个实例，并且为多个模块提供全局访问点。根据不同的应用场景和性能需求，选择合适的单例模式实现方式，可以有效提高系统的性能和资源利用率。

在实际开发中，推荐使用 静态内部类 或 枚举单例 这两种实现方式，因为它们既简单又能避免多线程问题和序列化问题，是相对优雅的单例模式实现方式。