单例模式：确保一个类只有一个实例【设计模式】

危险库2025-08-21 13:44

1. 引言：唯一性，有时是刚需

大家好。

在软件开发中，我们常常会遇到这样的场景：某个对象在整个应用程序的生命周期中，只需要一个实例。比如：

  • 日志管理器： 整个系统只需要一个日志对象来统一记录日志信息。
  • 配置管理器： 应用程序的配置信息应该由一个唯一的对象来加载和管理。
  • 线程池/数据库连接池： 资源管理类，为了避免资源浪费和冲突，通常只需要一个实例。

如果不对这些类的实例化进行控制，可能会导致资源浪费、数据不一致，甚至难以预料的错误。那么，如何才能确保一个类只有一个实例，并提供一个全局的访问点呢？答案就是------单例模式（Singleton Pattern）！

2. 什么是单例模式？

单例模式是一种创建型设计模式，它的核心意图是：

  1. 确保一个类只有一个实例： 这是单例模式最基本也是最重要的目标。它通过限制类的构造函数来防止外部随意创建新实例。
  2. 提供一个全局访问点： 既然只有一个实例，那么就需要一个统一、方便的途径来获取这个唯一的实例。

可以把单例模式想象成一个**"公司的 CEO"**：一个公司通常只有一个 CEO，并且所有需要 CEO 决策的事情，都必须通过这个唯一的 CEO 来处理。你不能随便"创建"一个新的 CEO，只能找到当前公司的那个 CEO。

3. 单例模式的核心结构与实现原理

单例模式的实现通常包含以下几个关键要素：

  1. 私有化构造函数： 将类的构造函数声明为 private 或 protected，这样外部代码就不能直接使用 new 或直接创建对象。
  2. 私有静态成员变量： 在类内部声明一个私有的、静态的成员变量，用于保存这个唯一的实例。
  3. 公共静态方法： 提供一个公共的、静态的方法（通常命名为 getInstance()），作为获取这个唯一实例的全局访问点。在这个方法内部，负责创建并返回唯一的实例。
3.1 C++ 实现：从非线程安全到线程安全

在 C++ 中实现单例模式，需要特别注意线程安全问题。

3.1.1 经典（非线程安全）实现

这是最直观的实现方式，但在多线程环境下是危险的。

cpp 复制代码 
#include <iostream>
#include <string>
#include <thread> // For std::thread

class Logger {
private:
    // 1. 私有构造函数，防止外部直接创建实例
    Logger() {
        std::cout << "Logger instance created." << std::endl;
    }

    // 2. 私有静态成员变量，用于保存唯一实例
    static Logger* instance;

public:
    // 3. 公共静态方法，提供全局访问点
    static Logger* getInstance() {
        if (instance == nullptr) { // 第一次调用时创建实例
            instance = new Logger();
        }
        return instance;
    }

    // 禁止拷贝构造函数和赋值运算符，确保唯一性
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;

    void log(const std::string& message) {
        std::cout << "[LOG] " << message << std::endl;
    }

    // 析构函数（可选，用于资源清理）
    ~Logger() {
        std::cout << "Logger instance destroyed." << std::endl;
    }
};

// 静态成员变量的定义（必须在类外部）
Logger* Logger::instance = nullptr;

// 测试函数
void test_logger() {
    Logger::getInstance()->log("Hello from thread!");
}

int main() {
    std::cout << "--- Non-thread-safe Singleton Test ---" << std::endl;

    // 单线程下正常工作
    Logger::getInstance()->log("Application started.");
    Logger::getInstance()->log("User logged in.");

    // 多线程问题：
    // 如果两个线程同时执行 getInstance()，并且都判断 instance == nullptr，
    // 那么可能会创建出两个 Logger 实例，违反了单例原则。
    std::thread t1(test_logger);
    std::thread t2(test_logger);

    t1.join();
    t2.join();

    Logger::getInstance()->log("Application ended.");

    // 注意：这里的 new Logger() 没有对应的 delete，存在内存泄漏。
    // 实际项目中需要考虑如何管理单例的生命周期，例如使用智能指针或在程序结束时手动释放。
    // 但更推荐下面的 Meyers' Singleton。

    return 0;
}

问题： 在多线程环境下，当 instance == nullptr 时，如果两个线程同时进入 if 块，它们都可能尝试创建 Logger 实例，导致创建出多个实例。

3.1.2 线程安全实现：Meyers' Singleton (C++11 推荐)

在 C++11 及更高版本中，实现线程安全的单例模式最简洁、最推荐的方式是利用局部静态变量的特性 ，这被称为 Meyers' Singleton。

关键点： C++11 标准规定，局部静态变量的初始化是线程安全的。如果多个线程同时尝试初始化同一个局部静态变量，只有一个线程会执行初始化，其他线程会阻塞并等待初始化完成。

cpp 复制代码 
#include <iostream>
#include <string>
#include <thread> // For std::thread
#include <mutex>  // For std::call_once (如果使用其他线程安全方式)

class ConfigManager {
private:
    // 1. 私有构造函数
    ConfigManager() {
        std::cout << "ConfigManager instance created." << std::endl;
        // 模拟加载配置
        configData = "Default Config";
    }

    // 2. 禁止拷贝构造函数和赋值运算符，确保唯一性
    ConfigManager(const ConfigManager&) = delete;
    ConfigManager& operator=(const ConfigManager&) = delete;

    std::string configData;

public:
    // 3. 公共静态方法，提供全局访问点
    static ConfigManager& getInstance() {
        // 局部静态变量：C++11 保证了其初始化是线程安全的 (Magic Statics)
        static ConfigManager instance;
        return instance;
    }

    void setConfig(const std::string& newConfig) {
        configData = newConfig;
        std::cout << "Config updated to: " << configData << std::endl;
    }

    std::string getConfig() const {
        return configData;
    }

    // 析构函数（可选，用于资源清理）
    ~ConfigManager() {
        std::cout << "ConfigManager instance destroyed." << std::endl;
    }
};

// 测试函数
void test_config_access(const std::string& threadName) {
    ConfigManager::getInstance().log("Accessing config from " + threadName);
    std::cout << threadName << " reads config: " << ConfigManager::getInstance().getConfig() << std::endl;
}

int main() {
    std::cout << "--- Meyers' Singleton (Thread-Safe) Test ---" << std::endl;

    // 第一次调用 getInstance()，实例才会被创建
    ConfigManager::getInstance().log("Application initialized.");
    ConfigManager::getInstance().setConfig("Initial Configuration");

    // 多线程访问，只会创建一次实例
    std::thread t1(test_config_access, "Thread A");
    std::thread t2(test_config_access, "Thread B");
    std::thread t3(test_config_access, "Thread C");

    t1.join();
    t2.join();
    t3.join();

    ConfigManager::getInstance().log("All threads finished.");
    std::cout << "Final config: " << ConfigManager::getInstance().getConfig() << std::endl;

    return 0;
}

输出示例：

复制代码 
--- Meyers' Singleton (Thread-Safe) Test ---
ConfigManager instance created.
[LOG] Application initialized.
Config updated to: Initial Configuration
[LOG] Accessing config from Thread A
Thread A reads config: Initial Configuration
[LOG] Accessing config from Thread B
Thread B reads config: Initial Configuration
[LOG] Accessing config from Thread C
Thread C reads config: Initial Configuration
[LOG] All threads finished.
Final config: Initial Configuration
ConfigManager instance destroyed.

可以看到，ConfigManager instance created. 只打印了一次，证明了实例的唯一性。

3.1.3 其他线程安全实现（了解即可）

  • 饿汉式 (Eager Initialization)： 在程序启动时就创建实例。简单，但可能浪费资源。

    cpp 复制代码 
    // static Logger instance; // 在类外部定义
// Logger::instance; // 在类内部声明

  • 双重检查锁定 (Double-Checked Locking, DCLP)： 在 C++11 之前常用，但需要配合内存屏障（std::atomic）才能保证完全正确，复杂且易错。

  • std::call_once： 使用 std::call_once 和 std::once_flag 确保某个函数只被调用一次。

    cpp 复制代码 
    // static std::once_flag onceFlag;
// static Logger* instance;
// static Logger* getInstance() {
//     std::call_once(onceFlag, []() { instance = new Logger(); });
//     return instance;
// }

    相比之下，Meyers' Singleton 更简洁、更安全。

4. 单例模式的适用场景

  • 需要唯一标识和访问的对象： 如日志系统、配置管理器、ID 生成器。
  • 资源管理器： 如线程池、数据库连接池，确保资源被统一管理和分配。
  • 全局状态管理： 虽然有争议，但在某些特定场景下，如游戏中的游戏状态管理器、GUI 应用的全局事件总线。
  • 某些驱动程序或设备接口： 确保只有一个实例与硬件交互。

5. 单例模式的优缺点

5.1 优点
  • 受控的唯一实例： 严格控制一个类的实例数量，确保只有一个。
  • 全局访问点： 可以在程序的任何地方方便地访问这个唯一的实例。
  • 延迟初始化（Lazy Initialization）： （对于懒汉式实现，如 Meyers' Singleton）实例只在第一次需要时才创建，节省资源。
  • 节省系统资源： 避免了重复创建和销毁对象，特别是在对象创建开销很大的情况下。
5.2 缺点 / 批评
  • 隐藏的全局状态： 单例本质上引入了全局状态，这使得代码的依赖关系不明确，增加了测试的难度（难以模拟或替换依赖）。
  • 违反单一职责原则（SRP）： 一个类不仅负责其核心业务逻辑，还要负责管理自身的创建和生命周期。
  • 难以测试： 由于是全局的，很难在单元测试中隔离和模拟单例对象。每次测试都可能使用同一个实例，导致测试之间相互影响。
  • 可能导致紧耦合： 程序的其他部分直接依赖于单例的 getInstance() 方法，使得模块间的耦合度增加。
  • 生命周期管理： 尤其是在 C++ 中，如果单例持有资源，其销毁时机可能成为问题（例如，静态对象的销毁顺序不确定）。Meyers' Singleton 的生命周期由编译器管理，通常在 main 函数结束后自动销毁，但如果其析构函数依赖于其他静态对象，可能会有销毁顺序问题。

6. 替代方案与现代 C++ 视角

鉴于单例模式的诸多缺点，尤其是在大型、复杂、需要高可测试性的系统中，现代软件设计倾向于避免滥用单例模式。

  • 依赖注入（Dependency Injection, DI）：

    • 这是最推荐的替代方案。它通过构造函数、setter 方法或接口，将依赖的对象显式地传递给需要它们的类。
    • 优点： 依赖关系清晰、模块解耦、易于测试（可以注入 Mock 对象）。
    • 示例： 不再通过 Logger::getInstance() 获取日志器，而是将 Logger 对象作为参数传递给需要日志功能的类。
    cpp 复制代码 
    // Logger 作为普通类
class Logger { /* ... */ };

class MyService {
private:
    Logger& logger; // 通过引用注入依赖

public:
    MyService(Logger& log) : logger(log) {} // 构造函数注入

    void doSomething() {
        logger.log("Doing something in MyService.");
    }
};

// main 函数中创建并传递
int main() {
    Logger appLogger; // 创建一个 Logger 实例
    MyService service(appLogger); // 注入 Logger
    service.doSomething();
    return 0;
}

  • 服务定位器（Service Locator）：

    • 提供一个注册和查找服务的中心容器。客户端通过名称从定位器中获取服务实例。
    • 优点： 避免了显式传递所有依赖。
    • 缺点： 隐藏了依赖关系，不如依赖注入清晰。

  • 将对象作为参数传递： 对于简单的场景，直接将需要共享的对象作为函数参数传递。

7. 总结与展望

单例模式提供了一种简单直接的方式来确保一个类只有一个实例并提供全局访问点。在某些特定场景下（如日志系统、配置管理），它仍然是一个有效的解决方案。

然而，它并非"银弹"。由于其引入的全局状态、对测试的影响以及对单一职责原则的违反，现代软件设计理念更倾向于使用依赖注入等方式来管理对象的生命周期和依赖关系，以构建更松耦合、更易于测试和维护的系统。

在决定使用单例模式之前，请务必权衡其优缺点，并考虑是否有更合适的替代方案。谨慎地选择和使用设计模式，才能真正提升代码质量。

相关推荐
sorryhc几秒前
【AI解读源码系列】ant design mobile——Image图片
前端·javascript·react.js
sorryhc29 分钟前
【AI解读源码系列】ant design mobile——Button按钮
前端·javascript·react.js
VOLUN30 分钟前
PageLayout布局组件封装技巧
前端·javascript·vue.js
掘金安东尼30 分钟前
React 的 use() API 或将取代 useContext
前端·javascript·react.js
蓝胖子的小叮当1 小时前
JavaScript基础（十三）函数柯里化curry
前端·javascript
前端Hardy1 小时前
HTML&CSS：有趣的SVG路径动画效果
javascript·css
前端Hardy2 小时前
HTML&CSS：超酷炫的3D动态卡片
前端·javascript·css
江城开朗的豌豆2 小时前
我在项目中这样处理useEffect依赖引用类型，同事直呼内行
前端·javascript·react.js
听风的码2 小时前
Vue2封装Axios
开发语言·前端·javascript·vue.js
Leo来编程2 小时前
设计模式1-单例模式
单例模式·设计模式
热门推荐
01UV安装并设置国内源02DeepSeek更新！速览DeepSeek V3.1新特性03Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code04KGG转MP3工具|非KGM文件|解密音频05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接06【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）072025最新国内服务器可用docker源仓库地址大全（2025年8月更新）08Spring 调试终于不再痛苦了09Claude Code VSCode集成开发指南：AI编程助手完整配置10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南