单例模式（Singleton）详解

1. 什么是单例模式？

单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。单例模式常用于需要控制资源的共享，例如数据库连接、线程池、日志记录等场景。

1.1 单例模式的结构

单例模式的核心思想是通过私有构造函数和静态方法来控制实例的创建。通常，单例类会包含一个静态变量来保存唯一的实例，并提供一个公共的静态方法来获取该实例。

2. 单例模式的优点

全局访问：单例模式提供了一个全局访问点，方便在整个应用程序中使用。
节省资源：由于只创建一个实例，减少了内存的使用，避免了重复创建对象的开销。
控制实例数量：确保系统中只有一个实例，避免了资源的竞争和冲突。

3. 单例模式的缺点

难以测试：单例模式可能会导致代码的耦合性增加，影响单元测试的独立性。
多线程问题：在多线程环境下，单例的实现需要特别小心，避免出现多个实例。
隐藏依赖：单例模式可能会导致隐藏的依赖关系，使得代码的可读性和可维护性降低。

4. 单例模式的实现

4.1 饿汉式单例

饿汉式单例在类加载时就创建实例，确保线程安全，但可能会造成资源浪费。

public class HungrySingleton {
    // 1. 创建一个静态实例
    private static final HungrySingleton INSTANCE = new HungrySingleton();

    // 2. 私有构造函数，防止外部实例化
    private HungrySingleton() {}

    // 3. 提供一个公共的静态方法获取实例
    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

4.2 懒汉式单例

懒汉式单例在第一次调用时创建实例，节省资源，但需要处理线程安全问题。

public class LazySingleton {
    // 1. 声明一个静态实例
    private static LazySingleton instance;

    // 2. 私有构造函数
    private LazySingleton() {}

    // 3. 提供一个公共的静态方法获取实例
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

4.3 线程安全的懒汉式单例

为了确保线程安全，可以使用同步方法或双重检查锁定。

4.3.1 同步方法

public class ThreadSafeLazySingleton {
    private static ThreadSafeLazySingleton instance;

    private ThreadSafeLazySingleton() {}

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

4.3.2 双重检查锁定

public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {}

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

4.4 静态内部类单例

静态内部类单例利用了类加载机制，确保线程安全且延迟加载。

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}

    private static class Holder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

5. 使用单例模式的注意事项

避免过度使用：单例模式并不适合所有场景，过度使用可能导致代码的复杂性增加。
序列化问题：如果单例类需要序列化，需实现 readResolve 方法以防止创建新的实例。
依赖注入：在需要测试的场景中，考虑使用依赖注入来替代单例模式，以提高代码的可测试性。

6. 结论

单例模式是一种常用的设计模式，适用于需要控制实例数量的场景。通过不同的实现方式，可以根据具体需求选择合适的单例模式。理解单例模式的优缺点及其实现方式，有助于在实际开发中更好地应用这一模式。