嘻哈说：设计模式之单例模式

一、单例模式：代码世界的”独行侠”

（核心概念）单例模式就像街头说唱中的”独行侠”——一个类只允许创建一个实例，并提供全局访问点。这种设计模式在需要严格控制资源访问的场景中至关重要，比如数据库连接池、线程池、日志管理器等。

1.1 为什么需要单例？

• 资源优化：避免重复创建高开销对象（如数据库连接）
• 状态同步：确保全局配置对象的状态一致性
• 控制访问：限制对共享资源的并发访问（如打印机驱动）

生活化类比：就像城市中的单轨列车，一条轨道上只能有一列火车运行，确保交通秩序。

二、实现单例的三大流派

（代码实战）根据初始化时机不同，单例实现可分为三大流派：

2.1 饿汉式：先吃为敬

public class EagerSingleton {
    // 类加载时即初始化
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {} // 私有构造器
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

特点：

• 线程安全（JVM保证类加载同步）
• 可能造成资源浪费（如果实例未被使用）

2.2 懒汉式：按需供应

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    // 同步方法实现（线程安全但性能低）
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

优化方案：双重检查锁定（DCL）

public class DCLSingleton {
    private volatile static DCLSingleton instance;
    private DCLSingleton() {}
    public static DCLSingleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (DCLSingleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

关键点：

• volatile关键字防止指令重排序
• 双重检查减少同步开销

2.3 静态内部类：优雅的延迟加载

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

优势：

• 线程安全（类加载机制保证）
• 延迟加载（只有调用getInstance时才初始化）

三、单例模式的”嘻哈禁忌”

（反模式警示）使用单例时需避开这些坑：

3.1 反模式1：多线程下的”双胞胎”

问题场景：未同步的懒汉式单例在多线程下可能创建多个实例

// 错误示范：非线程安全的懒汉式
public class UnsafeSingleton {
    private static UnsafeSingleton instance;
    public static UnsafeSingleton getInstance() {
        if (instance == null) {
            instance = new UnsafeSingleton(); // 并发问题
        }
        return instance;
    }
}

解决方案：使用上述DCL或静态内部类方案

3.2 反模式2：序列化破坏单例

问题场景：通过反序列化可创建新实例

public class SerializableSingleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static final SerializableSingleton INSTANCE = new SerializableSingleton();
    private SerializableSingleton() {}
    public static SerializableSingleton getInstance() {
        return INSTANCE;
    }
    // 必须实现readResolve防止反序列化破坏单例
    protected Object readResolve() {
        return getInstance();
    }
}

3.3 反模式3：反射攻击

问题场景：通过反射调用私有构造器

try {
    Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    Singleton newInstance = constructor.newInstance(); // 创建新实例
} catch (Exception e) {
    e.printStackTrace();
}

终极防御：在构造器中添加实例检查

private Singleton() {
    if (INSTANCE != null) {
        throw new IllegalStateException("单例已被初始化");
    }
}

四、单例模式的”嘻哈应用”

（实战场景）看看单例模式在实际开发中的酷炫应用：

4.1 配置管理器

public class ConfigManager {
    private static final ConfigManager INSTANCE = new ConfigManager();
    private Map<String, String> configMap;
    private ConfigManager() {
        // 从文件加载配置
        configMap = loadConfigFromFile();
    }
    public static ConfigManager getInstance() {
        return INSTANCE;
    }
    public String getConfig(String key) {
        return configMap.get(key);
    }
}

4.2 日志记录器

public class Logger {
    private static final Logger INSTANCE = new Logger();
    private PrintStream output;
    private Logger() {
        // 初始化日志输出流
        output = System.out; // 实际项目中可能是文件流
    }
    public static Logger getInstance() {
        return INSTANCE;
    }
    public void log(String message) {
        output.println("[LOG] " + message);
    }
}

五、单例模式的”嘻哈变体”

（进阶知识）根据需求不同，单例模式有多种变体：

5.1 线程单例（Thread Singleton）

每个线程维护自己的单例实例

public class ThreadSingleton {
    private static final ConcurrentHashMap<Long, ThreadSingleton> instances 
        = new ConcurrentHashMap<>();
    private ThreadSingleton() {}
    public static ThreadSingleton getInstance() {
        Long threadId = Thread.currentThread().getId();
        return instances.computeIfAbsent(threadId, k -> new ThreadSingleton());
    }
}

5.2 集群单例（Cluster Singleton）

分布式环境下的单例实现（需借助ZooKeeper等协调服务）

六、嘻哈总结：单例模式使用指南

（最佳实践）

1. 适用场景：

   • 需要严格控制实例数量的资源
   • 需要全局访问点的对象
   • 实例创建开销大的对象

2. 慎用场景：

   • 需要继承的类（单例模式与继承冲突）
   • 需要多实例的灵活配置
   • 单元测试困难的场景

3. 性能优化：

   • 优先选择静态内部类实现
   • 对性能敏感的场景考虑DCL模式
   • 避免在单例中保存大量状态

4. 替代方案：

   • 依赖注入框架（如Spring的@Singleton）
   • 对象池模式（当需要控制实例数量但非单一时）

嘻哈金句：单例模式就像代码世界的独行侠，用得好是系统稳定的守护者，用不好就成了并发问题的制造者。记住：控制资源要适度，全局访问需谨慎，线程安全是根本！