核心概念：单例模式
- 目的：确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。
- 应用场景：比如数据库连接池、线程池、日志对象、应用的配置类等。这些对象在程序中只需要一个实例即可，创建多个实例会浪费资源或导致行为异常。
饿汉式
核心思想：'饿'，顾名思义，很饥饿，所以在类加载的时候就已经创建好实例，不管后面用不用，先创建了再说。 特点：
- 线程安全：因为实例的创建是在类加载阶段完成的，这个阶段由 JVM 保证线程安全。
- 加载慢，获取快：类一加载就初始化实例，可能会稍微拖慢启动速度，但获取实例对象的速度非常快。
代码示例：
public class SingletonEager {
// 1. 私有静态实例，在类加载时就直接创建
private static final SingletonEager INSTANCE = new SingletonEager();
// 2. 私有构造函数，防止外部通过 new 关键字创建实例
private SingletonEager() {}
// 3. 公共的静态方法，用于获取唯一实例
public static SingletonEager getInstance() {
return INSTANCE;
}
}
优点：实现简单，绝对线程安全。
缺点：如果这个实例非常耗费资源，但在整个程序运行过程中又可能用不到，就会造成资源的浪费。
懒汉式
核心思想：'懒'，很懒惰，所以只有在第一次被用到的时候才创建实例。 特点：
- 资源利用率高：只有在需要的时候才创建，避免了不必要的资源消耗。
- 加载快，获取慢（第一次）：类加载时不初始化，第一次调用
getInstance()时才创建，所以第一次获取会稍慢。
基础版（非线程安全）
这个版本在多线程环境下会出问题。
public class SingletonLazy {
private static SingletonLazy instance;
// 不直接初始化
private SingletonLazy() {}
public static SingletonLazy getInstance() {
// 判断如果实例为空，则创建
if (instance == null) {
instance = new SingletonLazy();
// 问题所在：多个线程可能同时进入这里
}
return instance;
}
}
改进版（线程安全，使用 synchronized）
通过给方法加锁来解决线程安全问题，但效率较低。
public class SingletonLazySync {
private static SingletonLazySync instance;
private SingletonLazySync() {}
// 使用 synchronized 关键字，保证同时只有一个线程能进入该方法
public static synchronized SingletonLazySync getInstance() {
if (instance == null) {
instance = new SingletonLazySync();
}
return instance;
}
}
最优版（双重检查锁 DCL）
为了兼顾线程安全和效率，我们只在实例还没创建的时候进行同步。
public class SingletonLazyDCL {
// 使用 volatile 关键字，防止指令重排，保证可见性
private static volatile SingletonLazyDCL instance;
private SingletonLazyDCL() {}
public static SingletonLazyDCL getInstance() {
// 第一次检查，如果实例已存在，则直接返回，避免进入同步块，提高效率。
if (instance == null) {
// 加锁，确保只有一个线程能进入同步块
synchronized (SingletonLazyDCL.class) {
// 第二次检查，防止在等待锁的过程中，已有其他线程创建了实例。
if (instance == null) {
instance = new SingletonLazyDCL();
}
}
}
return instance;
}
}
为什么用 volatile？
instance = new SingletonLazyDCL(); 这行代码不是一个原子操作，它分为三步：
- 分配内存空间
- 初始化对象
- 将 instance 指向分配的内存地址
如果没有 volatile，JVM 可能会进行指令重排序，导致步骤 3 在步骤 2 之前执行。这样另一个线程可能在第一次检查时看到 instance 不为 null（已经指向了内存地址），但对象还没有初始化完成，从而拿到一个不完整的对象。volatile 可以禁止这种重排序。
总结对比
| 特性 | 饿汉式 | 懒汉式（基础版） | 懒汉式（双重检查锁） |
|---|---|---|---|
| 创建时机 | 类加载时 | 第一次调用 getInstance() 时 | 第一次调用 getInstance() 时 |
| 线程安全 | 是 | 否 | 是 |
| 资源利用 | 差，可能浪费 | 好 | 好 |
| 性能 | 获取实例快 | （线程不安全，无意义） | 第一次稍慢，之后快 |
| 实现难度 | 简单 | 简单 | 复杂 |
在现代 Java 开发中，还有更简洁的实现单例的方式，比如使用 枚举（Enum），它天生就是单例的，并且能防止反射和反序列化攻击，是《Effective Java》作者强烈推荐的方式。
public enum SingletonEnum {
INSTANCE;
// 这就是单例的实例
public void doSomething() {
// ... 业务方法
}
}
// 使用：SingletonEnum.INSTANCE.doSomething();
