单态模式概述

单态模式是一种创建型设计模式，其核心目标是在整个应用程序生命周期内，确保某个类仅有一个实例存在，并提供全局访问点。这种模式在需要严格控制资源访问、共享配置信息或维护全局状态的场景中尤为有用。例如，数据库连接池、线程池、日志记录器等组件，通常需要以单例形式存在，以避免重复创建导致的资源浪费或状态不一致问题。

单态模式的关键特性包括：

唯一实例：确保类只有一个实例，并提供全局访问点。
延迟初始化：实例在首次使用时创建，而非程序启动时。
线程安全：在多线程环境下，确保实例创建过程的安全性。
序列化与反序列化控制：防止通过序列化机制创建新实例。

单态模式的实现方式

单态模式的实现方式多样，每种方式各有优劣，适用于不同场景。以下将详细介绍几种常见的实现策略。

饿汉式单例

饿汉式单例在类加载时即完成实例化，线程安全且实现简单，但可能造成资源浪费。其实现代码如下：

public class EagerSingleton {
    // 类加载时即初始化实例
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    // 私有构造方法，防止外部实例化
    private EagerSingleton() {}
    // 提供全局访问点
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

适用场景：适用于实例创建开销较小，且程序启动后即需使用的场景。

懒汉式单例（非线程安全）

懒汉式单例在首次调用getInstance()方法时创建实例，但非线程安全实现可能导致多线程环境下创建多个实例。其实现代码如下：

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

问题：在多线程环境下，若两个线程同时执行if (instance == null)判断，可能导致创建多个实例。

懒汉式单例（线程安全）

为解决非线程安全问题，可通过同步方法或双重检查锁定（DCL）实现线程安全。

同步方法实现

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

优缺点：实现简单，但每次调用getInstance()均需同步，性能开销较大。

双重检查锁定（DCL）实现

public class DCLSingleton {
    // 使用volatile防止指令重排序
    private static volatile DCLSingleton instance;
    private DCLSingleton() {}
    public static DCLSingleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (DCLSingleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

原理：通过双重检查减少同步开销，volatile关键字防止指令重排序导致的问题。

静态内部类实现

静态内部类实现单例模式，结合了懒加载与线程安全的优点，且实现简洁。

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}
    private static class SingletonHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

原理：类加载时初始化静态内部类，实例在首次调用getInstance()时创建，且线程安全。

枚举实现

枚举实现单例模式，简洁且天然防止反射攻击与序列化问题。

public enum EnumSingleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("Singleton operation");
    }
}

优点：实现简单，线程安全，防止反射攻击与序列化问题。

单态模式的应用场景

单态模式适用于以下场景：

资源管理：如数据库连接池、线程池等，需严格控制资源数量。
配置管理：如全局配置对象，需统一访问与修改。
日志记录：如全局日志记录器，避免重复创建导致性能开销。
缓存管理：如全局缓存对象，需统一维护缓存状态。

单态模式的注意事项

线程安全：在多线程环境下，需确保单例创建过程的线程安全。
序列化与反序列化：若需序列化单例对象，需实现readResolve()方法防止创建新实例。
反射攻击：需防止通过反射机制创建新实例，可通过私有构造方法与枚举实现解决。
依赖注入：在大型项目中，可考虑通过依赖注入框架管理单例生命周期，而非手动实现。

结语

单态模式作为软件设计中的经典模式，其实现方式多样，各有优劣。开发者应根据具体场景选择合适的实现策略，确保单例的唯一性、线程安全性与性能。通过合理应用单态模式，可有效提升代码质量与系统性能，为构建健壮、高效的应用程序奠定基础。

单态模式：深入解析与实现策略