当前位置：首页 > article >正文

「全网最细 + 实战源码案例」设计模式——单例设计模式

article 2025/1/23 8:09:43

核心思想：

属于创建型设计模式，核心目的是确保一个类在整个程序运行期间只有一个实例，并提供一个全局访问点来获取该实例。
控制共享资源的访问（如数据库链接、配置管理、日志处理器等）
真实世界类比：政府是单例模式的一个很好的示例。一个国家只有一个官方政府。不管组成政府的每个人的身份是什么，“某政府” 这一称谓总是鉴别那些掌权者的全局访问节点。

结构

所有单例的实现都包含以下两个相同的步骤：

将默认构造函数设为私有，防止其他对象使用单例类的 new 运算符。
新建一个静态构建方法作为构造函数。该函数会“偷偷”调用私有构造函数来创建对象，并将其保存在一个静态成员变量中。此后所有对于该函数的调用都将返回这一缓存对象。

如果你的代码能够访问单例类，那它就能调用单例类的静态方法。无论何时调用该方法，它总是会返回相同的对象。

使用场景：

1. 需要唯一实例的场景：

配置管理类
日志记录器
数据库连接池
多线程环境中的任务调度器

2. 需要全局共享实例

以避免多个实例引发资源冲突或影响程序逻辑。

⭐实现方式：

1. 饿汉式（线程安全，类加载时初始化）

1.1. 静态变量式（常见方式）

// 饿汉式（静态变量）
public class Singleton {

    // 1. 私有化构造方法
    private Singleton() {}

    // 2. 创建一个静态变量，保存实例
    private static final Singleton instance = new Singleton();

    // 3. 提供一个公共的静态方法获取实例
    public static Singleton getInstance() {
        return instance;
    }
}

特点：

线程安全：类加载时实例化，JVM 保证线程安全。
缺点：类加载时即创建实例，即使未使用也会占用内存。

1.2. 静态代码块式

// 饿汉式（静态代码块）
public class Singleton {

    // 1. 私有化构造方法
    private Singleton(){}

    // 2. 创建一个静态对象
    private static Singleton instance;

    // 3. 在静态代码块中创建对象
    static {
        instance = new Singleton();
    }

    // 4. 提供获取对象的方法
    public static Singleton getInstance(){
        return instance;
    }
}

特点：

和静态变量方式类似，在类加载时实例化。
可以在静态代码块中加入额外逻辑，例如异常处理或配置初始化。

2. 懒汉式（线程不安全，延迟加载）

// 懒汉式，线程不安全
public class Singleton {

    // 1. 私有化构造方法
    private Singleton() {}

    // 2. 定义一个静态变量，用于存储唯一实例
    private static Singleton instance;

    // 3. 定义一个静态方法，用于获取唯一实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：

实例在第一次使用时才初始化，节约资源。

缺点：

多线程情况下可能创建多个实例，线程不安全。

3. 线程安全的懒汉式

3.1. 同步方法

// 懒汉式，同步式，线程安全
public class Singleton {

    // 1. 私有化构造方法
    private Singleton() {}

    // 2. 定义一个静态变量，用于存储
    private static Singleton instance;

    // 3. 定义一个静态方法，用于获取唯一实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

缺点：

同步方法会导致性能下降，尤其是高并发访问时。

3.2. 双重检查锁（推荐）

// 懒汉式，双重检查锁方式
public class Singleton {

    // 1. 私有化构造方法
    private Singleton() {}

    // 2. 定义一个静态变量，用于存储实例，volatile保证可见性与有序性，避免指令重排
    private static volatile Singleton instance;

    // 3. 定义一个静态方法，用于获取唯一实例
    public static Singleton getInstance() {
        // 1.第一次判断，如果instance的值为null，则进入同步代码块
        if (instance == null) {
            // 2.同步代码块，保证线程安全
            synchronized (Singleton.class) {
                // 3.第二次判断，如果instance的值为null，则创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

优点：

高效，只有在首次实例化时会加锁，之后不会。

注意：volatile 关键字防止指令重排，确保线程安全。

⭐为什么必须要加 `volatile`？

1、防止指令重排

在 Java 中，对象的实例化过程分为三步：

分配内存空间
初始化对象
将内存地址赋值给变量

由于指令重排的存在，步骤 2 和步骤 3 可能被调换执行。例如：

线程 A 在执行 instance = new Singleton() 时，可能执行了分配内存和赋值操作，但还未完成初始化。

此时，instance 已经不为 null，但它指向的对象尚未完全初始化。

如果线程 B 此时调用 getInstance()，判断 instance != null 为真，但实际访问的是一个未初始化完全的对象，这将导致程序出错。

加上 volatile 后，禁止指令重排序，确保初始化顺序正确。

2、保证变量的可见性

Java 的内存模型中，每个线程有自己的工作内存。一个线程对变量的修改，可能不会立即被其他线程所见。

加上 volatile 后，保证每次对 instance 的读操作都能获取到最新的值。

当线程 A 完成 instance 初始化后，其他线程（如 B 线程）立刻可见，而不会读取到旧值或中间状态。

3.3. ⭐静态内部类（推荐）

// 懒汉式，静态内部类方式
public class Singleton {
    
    // 1.构造函数私有化，外部不能new
    private Singleton() {}
    
    // 2.创建静态内部类
    private static class SingletonHolder {
        // 3.创建静态变量，保存实例
        private static final Singleton INSTANCE = new Singleton();
    }
    
    // 3.定义一个静态方法，用于获取唯一实例
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

原理：

由于 JVM 加载外部类的过程中，不会加载静态内部类，只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性。静态属性由于被 static 修饰，保证只会被实例化一次，并且严格保证实例化顺序。

优点：

线程安全
实现了延迟加载，按需初始化

4. ⭐枚举单例（最安全，推荐）

// 枚举单例
public enum Singleton {
    INSTANCE;
}

优点：

简单
天然防止反射和序列化破坏单例

破坏单例

1. 序列化破坏单例

问题：序列化和反序列化可以通过 ObjectInputStream 创建一个新的实例，而不是返回现有的单例实例。

示例代码：

import java.io.*;

public class Singleton implements Serializable {
    private static final long serialVersionUID = 1L;

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) throws Exception {
        Singleton instance1 = Singleton.getInstance();

        // 将对象序列化到文件
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton.obj"));
        oos.writeObject(instance1);
        oos.close();

        // 从文件反序列化对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton.obj"));
        Singleton instance2 = (Singleton) ois.readObject();

        // 验证是否为同一个实例
        System.out.println(instance1 == instance2); // 输出：false
    }
}

原因：

序列化机制会通过反序列化的过程创建一个新的对象实例，而不会调用单例类中的 getInstance() 方法。

解决方案：实现 readResolve() 方法，确保反序列化时返回现有实例。

private Object readResolve() {
    return INSTANCE;
}

2. 反射破坏单例

问题：通过反射，能够直接调用私有构造方法，创建多个实例。

示例代码：

import java.lang.reflect.Constructor;

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) throws Exception {
        Singleton instance1 = Singleton.getInstance();

        // 使用反射创建新实例
        Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton instance2 = constructor.newInstance();

        // 验证是否为同一个实例
        System.out.println(instance1 == instance2); // 输出：false
    }
}

原因：

反射可以访问私有构造方法并直接调用，从而绕过单例模式的限制。

解决方案：

1、在构造方法中防止重复实例化：

private static boolean isCreated = false;

private Singleton() {
    if (isCreated) {
        throw new RuntimeException("Singleton instance already created!");
    }
    isCreated = true;
}

2、使用枚举单例：

枚举类的单例天然防止反射和序列化破坏。

public enum Singleton {
    INSTANCE;
}

3. 总结

序列化破坏：通过 readResolve() 方法解决。
反射破坏：通过构造方法检查或使用枚举单例解决。
推荐方式：使用 枚举单例，最简单且最安全，能有效防止这两种破坏。

在源码中的应用

1. `Runtime` 类

简介：Runtime 类允许应用程序与运行时环境交互，比如调用垃圾回收、运行外部命令等。
实现方式：通过 饿汉式单例 实现。

源码分析：

public class Runtime {
    private static final Runtime currentRuntime = new Runtime(); // 饿汉式实例化

    private Runtime() {} // 私有化构造方法

    public static Runtime getRuntime() {
        return currentRuntime; // 返回唯一实例
    }

    public void gc() {
        // 调用垃圾回收
    }

    public void exit(int status) {
        // 退出 JVM
    }
}

特点：

全局唯一实例。
使用饿汉式，保证线程安全。

2. `Desktop` 类

简介：Desktop 类用来打开用户默认的应用程序（如浏览器、邮件客户端等）。
实现方式：通过 懒汉式单例 实现。

源码分析：

public final class Desktop {
    private static Desktop desktop;

    private Desktop() {}

    public static synchronized Desktop getDesktop() {
        if (desktop == null) {
            desktop = new Desktop(); // 懒汉式单例
        }
        return desktop;
    }

    public void browse(URI uri) {
        // 打开 URI
    }
}

特点：

使用同步方法保证线程安全。
懒加载，实例在需要时创建。

3. `Logger` 类（ `java.util.logging.Logger` ）

简介：Logger 是 Java 的日志工具类，用于记录和管理应用程序日志。
实现方式：内部使用单例模式管理全局日志管理器（LogManager）。

源码分析（核心部分）：

public class Logger {
    private static final LogManager manager = LogManager.getLogManager(); // 单例的 LogManager

    protected Logger(String name, String resourceBundleName) {
        // Logger 构造方法
    }

    public static Logger getLogger(String name) {
        return manager.getLogger(name); // 通过单例 LogManager 获取 Logger
    }
}