在我们之前的探讨中，我们已经对单例设计模式的基本概念及其在系统设计中的重要性有了初步的了解。既然你已经掌握了它的理论基础，那么在今天的文章中，我们将一起深入实战，看看如何在 Java 中创建既高效又线程安全的单例类。读完本文后，你将不再局限于“知道”单例模式，而是能够根据具体的业务场景（比如是追求极致的启动速度，还是处理高并发请求），选择最合适的实现方式，避免那些常见的性能陷阱和并发隐患。
在 Java 开发中，实现单例的方法五花八门。虽然这些代码在写法上各不相同，但归根结底，它们都围绕着同一个核心目标：确保一个类只有一个实例，并提供一个全局访问点。我们将从最简单的实现开始，逐步过渡到更复杂的线程安全方案。
1. 饿汉式初始化
这是创建单例类最简单、最直接的方法。就像它的名字一样，这种方法非常“急切”。在这种方法中，类的实例在类加载到内存时就会被立即创建。这通常通过直接静态赋值来完成。
何时使用？
这种方法适用于你的程序几乎肯定会使用该类的实例，或者创建实例的开销（资源和时间）不大，不值得为了延迟加载而增加代码复杂度。
代码示例：
// Java 代码示例：通过饿汉式初始化创建单例类
public class EagerExample {
// 在类加载时直接初始化静态实例
// final 关键字确保实例一旦创建就不能被改变
private static final EagerExample instance = new EagerExample();
// 私有构造函数，防止外部通过 new 关键字创建实例
private EagerExample() {
// 这里可以放置初始化代码
}
// 提供全局访问点
public static EagerExample getInstance() {
return instance;
}
}
深度解析与优缺点：
- 优点：
* 实现极其简单： 没有多余的逻辑，代码一目了然。
* 线程安全天然具备： 由于实例是在类加载时创建的，而类加载是由 JVM 保证的线程安全操作，所以不需要任何同步锁。
* 调用速度快： 调用 getInstance() 时，仅仅是返回一个已经创建好的引用，没有额外的逻辑开销。
- 缺点：
* 潜在的资源浪费： 这是最大的问题。无论你的程序运行过程中是否真的会使用这个单例对象，它都会被创建。如果构造函数中包含重量级的资源初始化（如加载大文件、建立网络连接），而程序运行中并未用到，这就是一种浪费。
* 缺乏灵活性： 如果实例的初始化依赖于某些参数或配置文件，而类加载时这些配置尚未准备好，这种方法就会失效。
* 异常处理受限： 如果在构造函数中抛出异常，且没有捕获，可能会导致类加载失败，从而无法使用该类。
2. 静态块初始化
这种方法实际上是饿汉式初始化的一个“变种”。它同样在类加载时就创建实例，但提供了一层控制逻辑。唯一的区别在于实例是在 static 静态代码块中创建的。
为什么需要它？
静态块给了我们更多的控制权。比如，我们可以在创建实例时进行异常处理，或者处理一些复杂的初始化逻辑，这些逻辑无法直接写在字段赋值那一行。
代码示例：
// Java 代码示例：使用静态块创建单例类
public class StaticBlockExample {
// 声明静态实例引用
public static StaticBlockExample instance;
// 私有构造函数
private StaticBlockExample() {
// 私有构造逻辑
}
// 静态代码块，在类加载时执行，用于初始化实例
static {
try {
// 这里可以加入异常处理或复杂的初始化逻辑
instance = new StaticBlockExample();
} catch (Exception e) {
// 可以在这里处理异常，或者记录日志
throw new RuntimeException("单例初始化失败", e);
}
}
public static StaticBlockExample getInstance() {
return instance;
}
}
深度解析与优缺点：
- 优点：
* 异常处理能力： 可以捕获和处理初始化时可能抛出的异常，增加了程序的健壮性。
* 逻辑集中： 可以将复杂的初始化逻辑放在静态块中，保持构造函数的整洁。
- 缺点：
* 保留了饿汉式的缺点： 依然会在类加载时创建实例，如果实例不被使用，依然会造成资源浪费和 CPU 时间的消耗。
* 可读性稍差： 相比直接赋值，静态块的方式在代码阅读上略显繁琐。
3. 懒汉式初始化
针对前两种方法可能造成的资源浪费问题，“懒汉式”提供了一个完美的解决方案。它的核心思想是“延迟加载”（Lazy Loading）：只有在真正需要用到对象的时候，才去创建它。
如何工作？
在这种方法中，我们将实例初始化为 INLINECODE83f45cbe。在 INLINECODE8cfb121a 方法中，首先检查实例是否为 null。如果是，则创建它；如果不是，则直接返回现有的实例。为了保证封装性，实例变量保持私有。
代码示例：
// Java 代码示例：通过懒汉式初始化创建单例类
public class LazyExample {
// 初始化为 null，不立即创建对象
private static LazyExample instance;
// 私有构造函数
private LazyExample() {
// 构造逻辑
}
// 获取实例的方法，包含逻辑判断
public static LazyExample getInstance() {
// 如果实例不存在，则创建
if (instance == null) {
instance = new LazyExample();
}
return instance;
}
}
深度解析与优缺点：
- 优点：
* 资源利用率高： 对象仅在第一次调用 getInstance() 时创建，节省了启动时的资源开销。
* 灵活性： 可以在方法内部进行异常处理，甚至可以根据不同的参数决定如何初始化（尽管单例通常无参）。
- 缺点：
* 线程安全问题： 这是致命伤。在多线程环境下，如果两个线程同时通过 if (instance == null) 的检查，它们可能会分别创建一个实例，导致单例模式失效。这也就是为什么我们通常说这种方法仅适用于单线程环境。
* 性能开销： 每次获取实例时都需要进行 null 检查（虽然这个开销很小，但在极高并发下也有影响）。
* 无法直接访问： 必须通过方法获取，不能直接访问静态变量（虽然这通常也是单例模式的预期行为）。
4. 线程安全的单例（同步方法）
为了解决懒汉式的并发问题，最直观的想法就是给 getInstance() 方法加锁，让它变成同步的。这样，同一时刻只有一个线程能进入该方法。
代码示例：
// Java 代码示例：创建线程安全的单例类
public class ThreadSafeExample {
private static ThreadSafeExample instance;
private ThreadSafeExample() {}
// 使用 synchronized 关键字修饰方法，确保同一时间只有一个线程能进入
synchronized public static ThreadSafeExample getInstance() {
if (instance == null) {
instance = new ThreadSafeExample();
}
return instance;
}
}
深度解析与优缺点：
- 优点：
* 线程安全： 哪怕有100个线程同时调用，也只会创建一个实例。这完全解决了并发破坏单例的问题。
- 缺点：
* 性能瓶颈严重： 这是一个“为了芝麻丢了西瓜”的方案。同步锁只需要在第一次创建对象时使用（即 INLINECODE840c68c5 为 INLINECODE10c9942f 时）。一旦对象创建好了，后续所有的 getInstance() 调用都只是读取操作，完全不需要加锁。但是，在这个实现中，每一次获取实例都会触发锁竞争，大大降低了并发性能。
5. 双重检查锁
既然我们只在第一次创建时需要同步，有没有办法只在 INLINECODE52eb960a 为 INLINECODE4b6ffd2f 的时候才加锁呢？这就是“双重检查锁”的由来。它是高性能并发应用中非常经典的一种写法。
如何工作？
- 第一次检查： 不加锁。如果实例已经存在，直接返回，避免不必要的锁等待。
- 加锁： 如果实例不存在，进入同步代码块。
- 第二次检查： 在锁内部再次检查。这是为了防止两个线程同时通过了第一次检查，等待锁的时候，前一个线程已经创建了实例，后一个线程拿到锁后就不应该再创建了。
- Volatile 关键字： 这一点至关重要。它能防止指令重排序，保证其他线程看到的对象一定是完全初始化好的。
代码示例：
// Java 代码示例：双重检查锁实现单例
public class DoubleCheckedLockingExample {
// 必须使用 volatile 关键字防止指令重排
private static volatile DoubleCheckedLockingExample instance;
private DoubleCheckedLockingExample() {}
public static DoubleCheckedLockingExample getInstance() {
// 第一次检查：如果实例不为空，直接返回，无需进入同步块
if (instance == null) {
// 锁定 Class 对象
synchronized (DoubleCheckedLockingExample.class) {
// 第二次检查：防止等待锁的线程重复创建
if (instance == null) {
instance = new DoubleCheckedLockingExample();
}
}
}
return instance;
}
}
6. 最佳实践：Bill Pugh 单例实现
虽然双重检查锁解决了性能问题，但代码稍微有点复杂，而且写错的话（比如忘记 volatile）很容易出事。Java 大神 Bill Pugh 提出了一种利用 Java 类加载机制特性的实现方式，被认为是目前实现单例的最佳实践之一。
原理：
利用 Java 的静态内部类。外部类加载时，不会立即加载静态内部类。只有在调用 getInstance() 访问内部类的静态成员时，JVM 才会加载内部类并初始化实例。由于类加载是线程安全的，这就天然实现了懒加载和线程安全，而且不需要任何同步锁。
代码示例：
// Java 代码示例：Bill Pugh 单例实现（静态内部类）
public class BillPughExample {
// 私有构造函数
private BillPughExample() {
// 防止通过反射攻击创建实例，可以在此添加判断
}
// 静态内部类，负责持有单例实例
private static class SingletonHelper {
// 只有在显式调用时才会加载
private static final BillPughExample INSTANCE = new BillPughExample();
}
public static BillPughExample getInstance() {
return SingletonHelper.INSTANCE;
}
}
7. 枚举单例
最后，我们要介绍的是一种被《Effective Java》作者 Josh Bloch 大力推荐的方式：使用枚举。这是 Java 语言特性级别的单例支持。
代码示例：
// Java 代码示例：使用枚举实现单例
public enum EnumSingleton {
INSTANCE;
// 可以在这里添加单例的方法
public void doSomething() {
System.out.println("枚举单例正在执行...");
}
}
为什么它是最好的？
- 绝对线程安全： Java 枚举的底层实现保证了这一点。
- 自动支持序列化机制： 普通的单例类在序列化和反序列化时，可能会创建新对象，破坏单例。而枚举单例由 JVM 专门保证，绝对不会发生这种情况。
- 防止反射攻击： 即使使用反射，也无法创建枚举类的新实例。
总结与建议
在这篇文章中，我们通过大量的代码示例，从简单的饿汉式到复杂的双重检查锁，再到优雅的静态内部类和枚举，一步步拆解了 Java 单例模式的实现细节。
- 如果你只是写一个简单的工具类，且内存占用不大，饿汉式是最快的选择。
- 如果你明确需要延迟加载且想要代码简洁，Bill Pugh（静态内部类）是首选。
- 如果你要面对极其复杂的序列化场景或需要绝对的防攻击能力，请毫不犹豫地选择枚举单例。
- 对于旧系统中常见的双重检查锁，虽然它很经典，但在现代 Java 开发中，它通常被更简洁的静态内部类实现所取代。
希望这些实战经验能帮助你在实际开发中写出更优雅、更健壮的代码！