类图+案例+代码详解：软件设计模式----单例模式

6、单例模式

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

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

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

比如：

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

用生活案例拆解核心逻辑：

为什么需要单例？

避免资源浪费：比如打印机驱动只需要加载一次

保证数据统一：比如全局配置类只能有一个实例存储参数

如何实现 "唯一"？

第一步：把构造方法设为private（不让别人随便 new）

第二步：自己在类里创建唯一的实例

第三步：提供一个公共方法让别人获取这个实例

代码示例

java 复制代码

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类型的。限定了每个执行该方法的线程必须彻底执行完以后，才能允许第二个线程执行该方法，从而确保了所创建对象的唯一性。

java 复制代码

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）

java 复制代码

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();做如下优化：

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

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

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

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

java 复制代码

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才会加载并创建实例