求Java单例模式实现案例

wen java案例 2026-08-10 4

深入剖析Java单例模式：7种实现方式与线程安全终极指南

目录导读

单例模式是什么？为什么需要它？
经典实现：饿汉式 vs 懒汉式
线程安全进阶：双重检查锁与volatile
优雅之路：静态内部类与枚举
防破解机制：序列化与反射攻击
常见问题FAQ（高频面试问答）
实战选择建议与性能对比

单例模式是什么？为什么需要它？

问答：单例模式的核心思想是什么？
单例模式确保一个类在全局范围内只有一个实例，并提供一个全局访问点，它常用于数据库连接池、配置管理器、线程池、日志系统等资源敏感场景，避免重复创建带来的性能损耗和状态不一致。

求Java单例模式实现案例

为什么不能直接用静态类？
静态类无法实现接口、无法延迟加载、无法被继承扩展，而单例对象可以像普通对象一样被传递和测试，更重要的是，单例模式能控制实例化时机，在真正需要时才创建（懒加载）。

经典实现：饿汉式 vs 懒汉式

1 饿汉式（线程安全，类加载即初始化）

public class EagerSingleton {
    // 类加载时即创建，天然线程安全
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {
        // 私有构造函数，防止外部new
    }
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

优点：实现简单，无并发问题。
缺点：类加载时就创建对象，若未使用则造成内存浪费。

2 懒汉式（非线程安全版，不推荐）

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton(); // 多线程下可能创建多个实例
        }
        return instance;
    }
}

问答：为什么懒汉式非线程安全？
当两个线程同时进入if (instance == null)判断，且此时instance均为null，两个线程都会执行new操作，导致创建两个不同对象，破坏单例原则。

线程安全进阶：双重检查锁与volatile

1 同步方法版（简单但性能差）

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

每次获取实例都需要竞争锁,即使实例已存在，性能低下。

2 双重检查锁（DCL）+ volatile

public class DoubleCheckSingleton {
    // volatile 防止指令重排序导致的“半初始化”问题
    private static volatile DoubleCheckSingleton instance;
    private DoubleCheckSingleton() {}
    public static DoubleCheckSingleton getInstance() {
        if (instance == null) {                        // 第一次检查
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) {                // 第二次检查（加锁）
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

为什么需要volatile？
new DoubleCheckSingleton()在JVM中分三步：分配内存、初始化对象、将引用指向内存，如果没有volatile，步骤2和3可能被重排，导致线程A尚未完成初始化时线程B就读取到了未初始化完成的引用，使用时抛出空指针异常。

优雅之路：静态内部类与枚举

1 静态内部类（推荐，兼顾懒加载与线程安全）

public class StaticInnerSingleton {
    private StaticInnerSingleton() {}
    // 静态内部类只有在主动调用时才被加载
    private static class Holder {
        private static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
    }
    public static StaticInnerSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

原理：JVM加载外部类时不会加载内部类，只有调用getInstance()时才对Holder类进行初始化，利用类加载机制保证线程安全，无需同步。

2 枚举实现（最安全，推荐用于反序列化）

public enum EnumSingleton {
    INSTANCE; // 枚举单例
    public void doSomething() {
        // 业务方法
    }
}

问答：为什么枚举是“单例之王”？

枚举构造函数私有,天然不可new。
枚举序列化时,JVM保证反序列化返回同一个实例（普通单例需重写readResolve()）。
反射无法通过newInstance()创建枚举实例（Enum类构造函数被特殊保护）。

防破解机制：序列化与反射攻击

1 防止序列化破坏单例

若普通单例类实现了Serializable接口，反序列化时会生成新实例，解决方案：

public class SafeSingleton implements Serializable {
    // 省略构造和getInstance...
    protected Object readResolve() {
        return getInstance(); // 反序列化时返回已存在实例
    }
}

2 防止反射攻击

private SafeSingleton() {
    if (instance != null) {
        throw new IllegalStateException("Cannot reflectively create singleton");
    }
}

此方法在构造器中判断实例是否已存在,若存在则直接抛异常。

常见问题FAQ（高频面试问答）

Q1：单例模式有哪些应用场景？
A：确保唯一性的场景均可使用，如：Spring的默认Bean作用域（单例）、数据库连接池、文件系统管理器、设备管理器（打印机、屏幕）、配置加载器（避免频繁读取配置文件）。

Q2：请对比饿汉式和懒汉式的选择策略？
A：若实例创建成本低且必须提前使用（如工具类），选饿汉式；若实例创建成本高且可能未被使用（如数据库连接），选静态内部类或DCL（懒加载）。

Q3：为什么双重检查锁中instance不能是普通变量？
A：普通变量可能因指令重排导致返回一个“半初始化”的实例，只有volatile修饰的变量禁止重排序，确保安全性。

Q4：枚举单例在反序列化时是如何保证唯一的？
A：Java规范规定，枚举的反序列化是通过valueOf()方法实现的，该方法会返回枚举常量本身，因此不会创建新对象。

Q5：Spring框架中的Bean是单例吗？单例模式与Spring单例有何区别？
A：Spring默认的Bean Scope为singleton，但它管理的是“按BeanId”的唯一实例，而并非传统JVM级别的单例，Spring单例可以拥有多个不同状态的Bean对象，且不限制类本身是否实现单例模式。

实战选择建议与性能对比

1 推荐优先级

实现方式	线程安全	懒加载
饿汉式	3星
DCL+volatile	4星
静态内部类	5星
枚举	否（加载即创建）	5星（万无一失）

2 性能对比（以10万次获取为例）

饿汉式/静态内部类：最快，无锁，直接返回引用。
DCL：第一次创建有锁开销，后续无锁，接近静态内部类。
枚举：加载时创建，获取速度同样极快。

3 最终建议

若需要最强的防序列化/反射保障，直接用枚举。
若在乎懒加载且代码简单,静态内部类是最优雅的折中方案。
若对性能有极致要求且初始化无副作用,饿汉式最精简。