设计模式是软件开发中经过验证的、可重用的解决方案。其中，单例（Singleton）模式是最基本也最常用的模式之一。它的核心思想是确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点来获取这个实例。这在日志记录器、配置管理器、线程池等场景中非常有用。
实现单例模式看似简单，但在多线程环境下保证线程安全和高性能却需要仔细考虑。本文将深入探讨三种常用且线程安全的 Java 单例实现方式：枚举、静态内部类和双重校验锁（Double-Checked Locking）。
1. 枚举（Enum）—— 《Effective Java》推荐的最佳实践
Joshua Bloch 在其著作《Effective Java》中极力推荐使用枚举来实现单例。这种方式不仅代码简洁，而且由 JVM 从根本上保证了线程安全、防止反序列化重新创建新对象以及防止通过反射攻击。
/**
* 使用枚举实现的单例模式
* 优点：实现简单、线程安全、防止反序列化和反射攻击
*/
public enum SingletonEnum {
INSTANCE; // 定义一个枚举元素，它本身就是单例的实例
// 可以添加其他方法
public void doSomething(String str) {
System.out.println("Enum Singleton doing: " + str);
}
// 示例用法
public static void main(String[] args) {
SingletonEnum singleton1 = SingletonEnum.INSTANCE;
SingletonEnum singleton2 = SingletonEnum.INSTANCE;
System.out.println(singleton1 == singleton2); // 输出 true
singleton1.doSomething("Hello World!");
}
}
工作原理：
- Java 枚举类型的实例是在类加载时由 JVM 保证唯一创建的。
- JVM 保证了枚举构造器的线程安全。
- 默认情况下，枚举实例的序列化和反序列化机制可以防止创建新对象。
- 反射机制也无法通过构造器创建新的枚举实例。
优点：
- 实现极其简单。
- 天然线程安全，无需任何同步措施。
- 有效防止反序列化和反射攻击。
- 代码可读性高。
缺点：
- 非懒加载（Lazy Loading），实例在枚举类加载时就被创建。但在大多数场景下，这不是问题。
结论： 如果你不需要延迟加载，枚举是实现单例模式的最简单、最安全的方式，强烈推荐。
2. 静态内部类（Static Inner Class）—— 兼顾线程安全与懒加载
静态内部类模式利用了 Java 类加载机制来保证线程安全和实现延迟加载。
/**
* 使用静态内部类实现的单例模式
* 优点：线程安全、懒加载、实现简单
*/
public class SingletonStaticInner {
// 1. 私有化构造方法
private SingletonStaticInner() {
System.out.println("SingletonStaticInner instance created.");
}
// 3. 定义静态内部类，持有单例实例
private static class SingletonInner {
// 在内部类中创建外部类实例，final确保不会被修改
private static final SingletonStaticInner INSTANCE = new SingletonStaticInner();
}
// 2. 对外提供获取实例的公共静态方法
public static SingletonStaticInner getInstance() {
// 首次调用该方法时，才会加载SingletonInner类，并创建INSTANCE
return SingletonInner.INSTANCE;
}
// 示例用法
public static void main(String[] args) {
System.out.println("Main method started.");
// 只有调用getInstance()时，才会触发内部类的加载和实例的创建
SingletonStaticInner instance1 = SingletonStaticInner.getInstance();
SingletonStaticInner instance2 = SingletonStaticInner.getInstance();
System.out.println(instance1 == instance2); // 输出 true
}
}
工作原理：
- 当外部类 SingletonStaticInner 被加载时，静态内部类 SingletonInner 并不会被立即加载。
- 只有当第一次调用 getInstance() 方法访问 SingletonInner.INSTANCE 时，JVM 才会加载 SingletonInner 类。
- 类的加载过程本身是线程安全的，JVM 会保证 INSTANCE 静态变量只被初始化一次。
优点：
- 线程安全： 由 JVM 类加载机制保证。
- 懒加载： 只有在第一次调用 getInstance() 时才创建实例。
- 实现简单： 相较于双重校验锁更简洁。
缺点：
- 仍然可能被反射攻击（可以通过在构造器中添加检查来防御）。
结论： 这是目前广泛使用的一种非常优秀的单例实现方式，兼顾了线程安全、懒加载和实现简洁性。
3. 双重校验锁（Double-Checked Locking, DCL）—— 兼顾性能与懒加载
双重校验锁旨在减少不必要的同步开销，以提高在高并发场景下获取实例的性能，同时实现懒加载。
/**
* 使用双重校验锁实现的单例模式
* 优点：线程安全、懒加载、性能较好（相比每次都同步）
* 缺点：实现复杂，容易出错（尤其volatile关键字）
*/
public class SingletonDCL {
// 1. volatile 保证可见性和禁止指令重排序
private volatile static SingletonDCL uniqueInstance;
// 2. 私有化构造方法
private SingletonDCL() {
System.out.println("SingletonDCL instance created.");
}
// 3. 对外提供获取实例的公共静态方法
public static SingletonDCL getUniqueInstance() {
// 第一次检查：如果实例已存在，直接返回，避免进入同步块
if (uniqueInstance == null) {
// 同步块：确保只有一个线程能创建实例
synchronized (SingletonDCL.class) {
// 第二次检查：防止多个线程同时通过第一次检查后重复创建实例
if (uniqueInstance == null) {
// 创建实例
uniqueInstance = new SingletonDCL();
}
}
}
return uniqueInstance;
}
// 示例用法
public static void main(String[] args) {
System.out.println("Main method started.");
// 并发测试 (仅为示意，实际测试需要更复杂的工具)
Thread t1 = new Thread(() -> System.out.println(SingletonDCL.getUniqueInstance()));
Thread t2 = new Thread(() -> System.out.println(SingletonDCL.getUniqueInstance()));
t1.start();
t2.start();
}
}
工作原理与 volatile 的关键性：
DCL 的核心在于两次 if (uniqueInstance == null) 检查和 synchronized 块。然而，volatile 关键字是 DCL 能够正确工作的关键。
正如你提供的解释中所述，uniqueInstance = new SingletonDCL(); 这行代码并非原子操作，它大致分为三步：
- 分配内存空间：为 uniqueInstance 对象分配内存。
- 初始化对象：调用 SingletonDCL 的构造函数，进行初始化。
- 建立引用：将 uniqueInstance 变量指向分配好的内存地址。
没有 volatile，JVM 的指令重排序可能导致执行顺序变为 1 -> 3 -> 2。在多线程下：
- 线程 T1 执行了步骤 1 和 3，uniqueInstance 此时非空，但对象未初始化。
- 线程 T2 调用 getUniqueInstance()，第一次检查 uniqueInstance == null 为 false，直接返回了一个未完全初始化的对象。
- 线程 T2 使用这个不完整的对象，可能导致程序错误。
volatile 关键字通过以下两点解决了这个问题：
- 禁止指令重排序：确保初始化（步骤 2）一定在赋值（步骤 3）之前完成。
- 保证可见性：确保一个线程对 uniqueInstance 的修改（写入 volatile 变量）能立刻被其他线程看到（读取 volatile 变量）。
优点：
- 线程安全： 正确实现（带 volatile）是线程安全的。
- 懒加载： 只有在需要时才创建实例。
- 性能： 实例创建后，后续获取不再需要同步，理论上性能优于每次都同步的方法。
缺点：
- 实现复杂： 相较于前两种方式更复杂，容易因忘记 volatile 或理解不清而出错。
- 性能优势不明显： 现代 JVM 对 synchronized 优化得很好，DCL 的性能优势可能不如预期，尤其是在低并发或无竞争时。
- 可能被反射攻击。
结论： DCL 是一种可行的方案，但实现较为复杂且容易出错。在现代 Java 中，除非有明确的性能瓶颈指向同步开销且无法使用前两种方式，否则一般不优先推荐 DCL。
总结与推荐
选择哪种单例实现方式取决于具体需求：
最佳选择（默认推荐）：枚举（Enum）
- 优点：最简单、最安全（线程、序列化、反射）、代码清晰。
- 缺点：非懒加载。
优秀选择（懒加载场景）：静态内部类（Static Inner Class）
- 优点：线程安全、实现懒加载、代码相对简单。
- 缺点：可能被反射攻击。
备选方案（复杂场景）：双重校验锁（Double-Checked Locking）
- 优点：线程安全、实现懒加载、理论上性能较好（避免后续同步）。
- 缺点：实现复杂、易错（volatile 关键）、性能优势可能不明显、可能被反射攻击。
理解这三种单例模式的实现原理、优缺点和适用场景，能帮助你在实际开发中做出更明智的选择，编写出更健壮、更高效的代码。