异常教程

单例模式（保姆级教程）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言：从厨房里的唯一厨师说起

在软件开发中，我们常常需要确保某个类仅有一个实例存在，并且全局可以访问这个实例。例如，一个厨房里的厨师长通常只有一个，他负责协调所有烹饪工作，其他员工只能通过这个唯一的厨师长来获取食材或下达指令。这种“唯一且全局可访问”的设计思想，正是单例模式的核心理念。

单例模式（Singleton Pattern）作为经典的设计模式之一，被广泛应用于资源管理、日志记录、配置中心等场景。本文将通过通俗的比喻、代码示例和实际案例，帮助读者理解单例模式的实现原理、应用场景及注意事项。

单例模式的基本概念

核心定义

单例模式确保一个类只有一个实例，并提供一个全局访问点（即全局静态方法或属性）。其核心特性包括：

  1. 单例性：类只能被实例化一次；
  2. 全局可访问性：实例可通过统一接口获取；
  3. 延迟加载（可选）：实例在首次调用时才被创建。

类比理解

想象一个图书馆的“管理员”角色：无论有多少读者需要借书，图书馆只会雇佣一名管理员来处理所有借阅请求。读者无需关心管理员的具体位置，只需通过“总服务台”找到他即可。这就是单例模式的直观体现。

单例模式的实现方式

基础实现：饿汉式与懒汉式

1. 饿汉式（Eager Initialization）

饿汉式在类加载时就直接创建实例，无需等待首次调用。其代码结构如下：

public class Singleton {  
    // 私有静态实例，类加载时初始化  
    private static final Singleton INSTANCE = new Singleton();  

    // 私有构造函数，防止外部实例化  
    private Singleton() {  
        // 初始化逻辑  
    }  

    // 公共静态方法获取实例  
    public static Singleton getInstance() {  
        return INSTANCE;  
    }  
}

特点：

  • 线程安全：无需额外同步，因为类加载是线程安全的；
  • 资源占用：实例在类加载时就占用资源，可能造成浪费。

2. 懒汉式（Lazy Initialization）

懒汉式在首次调用时才创建实例，延迟加载。基础实现如下：

public class Singleton {  
    private static Singleton instance;  

    private Singleton() {}  

    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

问题：

  • 线程不安全：在多线程环境下，可能创建多个实例。

进阶实现：线程安全与优化

1. 双重检查锁定（Double-Checked Locking）

通过加锁和空值检查来保证线程安全，同时减少性能损耗：

public class Singleton {  
    // volatile 关键字确保可见性，避免指令重排序  
    private static volatile Singleton instance;  

    private Singleton() {}  

    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

关键点：

  • volatile 关键字防止 JVM 指令重排序，保证可见性；
  • 双重检查避免每次调用都加锁，提升性能。

2. 静态内部类（Static Inner Class）

利用 Java 类加载机制的特性，实现延迟加载和线程安全：

public class Singleton {  
    // 私有构造函数  
    private Singleton() {}  

    // 静态内部类持有实例  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  

    public static Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

原理：

  • 静态内部类 SingletonHolder 只在首次调用 getInstance() 时加载，确保延迟加载；
  • 类加载由 JVM 保证线程安全，无需额外同步。

其他语言的实现示例

Python 实现

class Singleton:  
    _instance = None  

    def __new__(cls, *args, **kwargs):  
        if not cls._instance:  
            cls._instance = super().__new__(cls)  
        return cls._instance  

s1 = Singleton()  
s2 = Singleton()  
print(s1 is s2)  # 输出：True

JavaScript 实现

class Singleton {  
    constructor() {  
        if (!Singleton.instance) {  
            this.init();  
            Singleton.instance = this;  
        }  
        return Singleton.instance;  
    }  

    init() {  
        // 初始化逻辑  
    }  
}  

const s1 = new Singleton();  
const s2 = new Singleton();  
console.log(s1 === s2); // 输出：true

单例模式的应用场景

典型场景分析

1. 系统配置管理

在应用程序中，配置信息（如数据库连接参数、API 密钥）通常需要全局唯一且只读。通过单例模式，可以集中管理这些配置，避免重复加载或修改。

2. 日志记录系统

日志记录器（如 Logger）通常需要统一收集所有模块的日志，并写入同一个文件或数据库。单例模式确保所有调用者共享同一个日志实例。

3. 数据库连接池

数据库连接池需要管理有限的数据库连接资源。通过单例模式，可以避免多个实例重复创建连接，提高资源利用率。

4. 硬件设备访问

某些硬件设备（如打印机、串口设备）只能被一个实例控制。单例模式可防止多个线程同时操作设备引发的冲突。

实际案例：日志记录器的单例实现

public class Logger {  
    private static Logger instance;  
    private File logFile;  

    private Logger() {  
        try {  
            logFile = new File("system.log");  
            if (!logFile.exists()) {  
                logFile.createNewFile();  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  

    public static Logger getInstance() {  
        if (instance == null) {  
            instance = new Logger();  
        }  
        return instance;  
    }  

    public void log(String message) {  
        // 写入日志文件的逻辑  
    }  
}

使用方式：

Logger logger = Logger.getInstance();  
logger.log("系统启动成功");

单例模式的优缺点分析

优势

  1. 资源控制：避免重复创建资源密集型对象（如数据库连接、文件句柄）；
  2. 全局访问：通过统一接口获取实例，降低模块间的耦合度；
  3. 简化配置：集中管理共享资源的初始化和配置。

局限

  1. 隐藏的耦合性：过度使用可能导致系统难以测试和维护；
  2. 线程安全复杂度：多线程环境下需额外处理同步问题；
  3. 反序列化风险：未处理反序列化时，可能破坏单例性（需重写 readResolve 方法）。

单例模式的进阶技巧

1. 线程安全的加强

在 Java 中，通过 volatile 关键字和双重检查锁定可避免多线程问题。此外，静态内部类方案天然线程安全。

2. 序列化与反序列化的处理

若单例类需要序列化，需重写 readResolve() 方法，确保反序列化返回唯一实例：

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

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

    private Singleton() {}  

    public static Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  

    // 防止反序列化创建新实例  
    protected Object readResolve() {  
        return getInstance();  
    }  
}

3. 枚举实现（Java 特有）

Java 中推荐使用枚举实现单例，因其天然线程安全且防止反序列化破坏：

public enum Singleton {  
    INSTANCE;  

    public void performTask() {  
        // 实例方法  
    }  
}

使用方式：

Singleton.INSTANCE.performTask();

单例模式的替代方案

1. 依赖注入（Dependency Injection）

通过框架（如 Spring）管理单例对象，避免硬编码单例模式。

2. 对象池（Object Pool）

当需要有限但多个实例时，可考虑对象池模式，而非严格的单例。

3. 静态方法与工具类

对于无状态的工具类（如 StringUtils），可通过静态方法直接调用，无需单例。

结论：单例模式的正确使用之道

单例模式如同一把双刃剑：它能高效管理资源，但也可能因过度使用而降低代码的可维护性。开发者需根据场景权衡利弊：

  • 适用场景：资源有限、需要全局协调的场景（如配置、日志、连接池）；
  • 避免滥用：避免因“方便”而将一切对象变为单例，导致系统僵化。

掌握单例模式的核心思想后，开发者可以结合语言特性（如 Java 的枚举、Python 的 __new__ 方法）灵活实现，并通过单元测试验证线程安全性和唯一性。

记住：设计模式是工具，而非教条。理解其本质，才能在实际开发中游刃有余。

（全文约 1800 字）

最新发布

查看更多文章