Java面试核心：手写单例模式全解析

一、单例模式的核心价值与面试场景

单例模式作为创建型设计模式的代表，其核心目标是通过唯一实例控制确保一个类仅有一个对象存在，并提供全局访问点。在面试场景中，该模式常被用于考察候选人对以下维度的掌握：

1. 线程安全：能否在多线程环境下保证实例唯一性
2. 性能优化：如何平衡延迟加载与访问效率
3. 编码规范：代码可读性、异常处理及序列化兼容性
4. 设计原则：与开闭原则、单一职责原则的关联

典型面试问题包括：”如何实现线程安全的单例模式？””双重检查锁存在什么问题？””如何防止单例对象被反射破坏？”

二、四种标准实现方式详解

1. 饿汉式单例（Eager Initialization）

核心机制：类加载时即完成实例化，利用JVM类加载机制保证线程安全。

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {} // 私有构造器
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

特性分析：

• 线程安全：类加载阶段初始化，天然避免多线程问题
• 资源占用：无论是否使用，实例始终存在内存中
• 适用场景：实例创建开销小且必须立即使用的场景

面试要点：需说明final修饰符的作用（防止实例被重新赋值），以及私有构造器如何阻止外部实例化。

2. 懒汉式单例（Lazy Initialization）

基础实现：首次调用时创建实例，但存在线程安全问题。

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

同步优化：添加synchronized关键字保证线程安全，但带来性能损耗。

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

特性分析：

• 延迟加载：真正需要时才创建实例
• 性能瓶颈：同步方法导致高并发下性能下降
• 改进方向：双重检查锁或静态内部类方案

3. 双重检查锁单例（Double-Checked Locking）

核心机制：通过两次null检查减少同步开销，配合volatile防止指令重排序。

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

关键细节：

• volatile作用：禁止指令重排序，确保对象完全初始化后被其他线程访问
• 适用版本：JDK5及以上（volatile语义修正后）
• 性能优势：仅在首次创建时同步，后续访问无锁

面试陷阱：需强调volatile的必要性，若省略会导致其他线程可能获取到未初始化完成的对象。

4. 静态内部类单例（Holder Pattern）

核心机制：利用类加载机制保证线程安全，同时实现延迟加载。

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

特性分析：

• 线程安全：内部类加载时初始化，由JVM保证原子性
• 延迟加载：只有调用getInstance()时才会加载内部类
• 代码简洁：无需显式同步或volatile修饰
• 推荐指数：JDK1.5后最优雅的实现方式

三、单例模式的高级考量

1. 反射攻击防御

问题描述：通过反射调用私有构造器可破坏单例。
解决方案：在构造器中添加实例存在性检查。

private EagerSingleton() {
    if (INSTANCE != null) {
        throw new IllegalStateException("Singleton already initialized");
    }
}

2. 序列化破坏防御

问题描述：反序列化会创建新实例。
解决方案：实现readResolve()方法返回唯一实例。

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

或使用enum实现（天然防反射和序列化）：

public enum EnumSingleton {
    INSTANCE;
    // 可添加方法
}

3. 容器式单例（多例管理）

扩展场景：需要管理多个单例实例时。

public class SingletonManager {
    private static Map<String, Object> instanceMap = new HashMap<>();
    private SingletonManager() {}
    public static void registerService(String key, Object instance) {
        if (!instanceMap.containsKey(key)) {
            instanceMap.put(key, instance);
        }
    }
    public static Object getService(String key) {
        return instanceMap.get(key);
    }
}

四、面试应对策略

1. 基础题回答框架：

   • 明确需求：延迟加载/立即加载、线程安全要求
   • 选择实现：根据场景推荐最优方案（如静态内部类）
   • 说明原理：类加载机制/volatile语义/双重检查逻辑

2. 进阶题准备：

   • 如何实现集群环境下的单例？（需结合分布式锁）
   • 单例模式与依赖注入框架的关系？（如Spring的@Bean作用域）
   • 性能对比：同步方法 vs 双重检查锁 vs 静态内部类

3. 代码手写要点：

   • 私有构造器必须存在
   • 实例变量建议使用final修饰
   • 同步块范围尽可能小
   • 考虑序列化和反射的兼容性

五、最佳实践建议

1. 优先选择：静态内部类方案（JDK1.5+环境）
2. 兼容性方案：枚举单例（需处理复杂初始化时慎用）
3. 性能敏感场景：双重检查锁（确保理解volatile语义）
4. 避免：简单同步方法（除非实例创建开销极大且调用频率低）

通过系统掌握上述实现方式及其原理，开发者不仅能从容应对面试问题，更能在实际项目中根据具体需求选择最合适的单例实现方案。建议结合《Effective Java》中”考虑用静态工厂方法代替构造器”的条款进行深入理解，同时关注Java内存模型对并发编程的影响。