单例模式确保一个类只有一个实例，并提供全局访问点。核心实现包括：私有化构造方法、提供静态获取实例的方法。适用于全局唯一场景如ATM总控中心、任务管理器等。在多线程环境下，需考虑线程安全问题，常见解决方案包括：同步锁办法（简单但低效）、双重检查锁定（DCL，需搭配volatile防止指令重排）以及最优的静态内部类方式（利用类加载机制保证线程安全）。静态内部类方案兼具线程安全和延迟加

6、单例模式

指确保一个类仅有一个唯一的实例，并提供一个全局访问点。

所以把构造方法进行私有化，声明为 private 类型；同时提供一个获得实例的方法 getInstance() ，为public类型，并且是static，用于返回该类的实例。

核心思想：全世界只能有一个我 —— 保证类永远只有一个对象

比如：

• 银行的 ATM 机系统，只能有一个 “总控中心” 管理所有机器
• 电脑的 “任务管理器”，无论点多少次打开，永远只弹出同一个窗口
• 单例模式就是让类具备 “全球唯一” 的特性

用生活案例拆解核心逻辑：
为什么需要单例？
避免资源浪费：比如打印机驱动只需要加载一次
保证数据统一：比如全局配置类只能有一个实例存储参数

如何实现 “唯一”？
第一步：把构造方法设为private（不让别人随便 new）
第二步：自己在类里创建唯一的实例
第三步：提供一个公共方法让别人获取这个实例

代码示例

public class President
{
// 静态单例实例，类加载时初始化，保证唯一
private static President instance;
private String name;
// 私有构造方法，防止外部直接实例化
private President(String name) {
this.name = name;
}
// 静态工厂方法，提供获取单例实例的途径
public static President getInstance(String name) {
// 检查实例是否未创建，且传入的名称不为 null
if (instance == null && name != null) {
// 创建单例实例，传入名称参数
instance = new President(name);
}
// 返回单例实例，若未满足创建条件，可能返回 null
return instance;
}
}

多线程下的单例模式

给 “唯一实例” 加把 “线程安全” 的锁

为什么多线程需要特殊的单例？
想象两个用户同时抢最后 1 张演唱会门票，如果单例模式没考虑多线程，可能出现：
1.用户 A 检查到 “剩余票数 = 1”，准备购买
2.用户 B 同时检查到 “剩余票数 = 1”，也准备购买
3.最终两人都买到票，但实际库存只扣了 1 张 —— 这就是线程安全问题

3 种多线程单例实现：从简单到高效

1. 最直接的方案：synchronized 锁整个方法
使用同步机制，将 getInstance() 方法声明为static synchronized类型的。限定了每个执行该方法的线程必须彻底执行完以后，才能允许第二个线程执行该方法，从而确保了所创建对象的唯一性。

public class SynchronizedSingleton
{
private static SynchronizedSingleton instance;
private SynchronizedSingleton() {
}
// 给获取实例的方法加锁，保证同一时间只有一个线程能进入
public static synchronized SynchronizedSingleton getInstance() {
if (instance == null) {
instance = new SynchronizedSingleton();
}
return instance;
}
}

缺点：锁范围太大，每次调用getInstance()都要排队，效率低

2. 优化版：双重检查锁定（DCL）

public class DoubleCheckSingleton
{
private static volatile DoubleCheckSingleton instance;
// 关键：volatile防止指令重排
private DoubleCheckSingleton() {
}
public static DoubleCheckSingleton getInstance() {
// 第一次检查：实例存在则直接返回，避免无意义加锁
if (instance == null) {
synchronized (DoubleCheckSingleton.class)
{
// 锁类对象，范围更小
// 第二次检查：可能有多个线程同时通过第一次检查，需再次确认
if (instance == null) {
instance = new DoubleCheckSingleton();
// 这里可能发生"指令重排"，volatile禁止重排
}
}
}
return instance;
}
}

核心技巧：

• 双重检查：先判断是否为空，避免每次都加锁
• volatile 关键字：防止 JVM 优化时指令重排，避免返回未初始化的实例

为什么 DCL 需要 volatile？一个危险的例子：

假设没有volatile，JVM 可能对instance = new DoubleCheckSingleton();做如下优化：

1. 分配内存空间
2. 先赋值引用（instance 指向未初始化的对象）
3. 执行构造方法初始化对象

如果线程 A 执行到步骤 2 时，线程 B 刚好调用getInstance()：

• 线程 B 发现instance != null，直接返回未初始化的对象
• 此时访问instance会导致空指针异常或数据错误

3. 终极方案：静态内部类（推荐）

public class InnerClassSingleton
{
private InnerClassSingleton() {
}
// 静态内部类只有在被调用时才会加载，天然线程安全
private static class SingletonHolder
{
private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
}
// 调用时才会触发SingletonHolder的加载，实现延迟初始化
public static InnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}

原理：

• Java 类加载机制保证：静态内部类的初始化是线程安全的
• 只有当getInstance()被调用时，SingletonHolder才会加载并创建实例