设计模式：单例模式

文章目录

- 一、单例模式的概念
- 二、单例模式结构
- 三、函数内静态变量初始化的线程安全问题
- 四、常见实现方式
- - [3.1 饿汉式单例](#3.1 饿汉式单例)
  - [3.2 懒汉式单例](#3.2 懒汉式单例)

一、单例模式的概念

单例模式（Singleton Pattern）是一种创建型设计模式，它的核心思想是：保证在一个进程中，某个类仅有一个实例，并提供全局访问点。

常见应用场景：

日志系统：全局唯一的日志记录器。

配置管理：全局读取配置文件。

线程池、数据库连接池：全局资源管理。

设备驱动对象：保证唯一控制入口。

单例模式的关键要素：

构造函数私有化：防止外部随意 new。

拷贝构造与赋值运算符删除：防止复制对象。

静态成员指针/对象：存储唯一实例。

公共静态方法：提供获取实例的入口。

二、单例模式结构

三、函数内静态变量初始化的线程安全问题

在 C++98/03 中：

函数内的静态局部变量在第一次调用函数时初始化。

多线程调用时，如果两个线程同时进入函数，就可能同时执行初始化，造成多次构造，属于竞态条件（Race Condition）。

所以在 C++98/03 里，需要手动加锁才能保证安全。

C++11 标准明确规定：函数内静态局部变量在第一次初始化时，初始化过程是线程安全的。

也就是说：

即使多个线程同时调用 getInstance()，只有一个线程会执行构造函数。

其他线程会等待构造完成，然后使用同一个实例。

四、常见实现方式

3.1 饿汉式单例

饿汉式的特点：

类加载时就创建实例，不管你用不用它，它都存在。

线程安全：因为实例在程序开始时就初始化了，不存在多线程并发创建的问题。

资源消耗：如果对象很大而一直没用到，会浪费内存。

适用场景：对象创建成本低，且在程序运行中几乎一定会用到。

静态成员对象

cpp 复制代码

#include <iostream>

class Singleton {
private:
    Singleton() { std::cout << "Singleton Created\n"; } // 构造函数私有化
    ~Singleton() { std::cout << "Singleton Destroyed\n"; }

    Singleton(const Singleton&) = delete;               // 禁止拷贝
    Singleton& operator=(const Singleton&) = delete;    // 禁止赋值

    static Singleton instance;   // 静态成员，类加载时即初始化

public:
    static Singleton& getInstance() {
        return instance;         // 返回唯一实例
    }

    void show() {
        std::cout << "Hello Hungry Singleton!" << std::endl;
    }
};

// 静态成员初始化（在程序启动时创建）
Singleton Singleton::instance;

int main() {
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();

    s1.show();
    std::cout << "s1 addr = " << &s1 << ", s2 addr = " << &s2 << std::endl;
    return 0;
}

输出结果：

实现原理（简要）：

编译器在生成代码时，会在静态变量前加上一次性标志（guard variable）。

第一个线程进入函数时，检查标志：

如果未初始化 → 执行构造函数 → 设置标志

如果已初始化 → 直接返回实例

编译器会保证对标志的写入和检查是原子操作或通过内部锁完成，从而保证线程安全。

3.2 懒汉式单例

懒汉式的特点：

延迟初始化：只有第一次调用 getInstance() 时才创建对象。

线程安全问题：多线程环境下，需要注意可能出现多个实例的问题。

优点：节省资源，只有在真正需要时才创建。

缺点：实现稍复杂，需要考虑多线程安全。

懒汉式实现（C++11 推荐写法）

C++11 后，使用函数内静态变量可以保证线程安全：

cpp 复制代码

#include <iostream>

class Singleton {
private:
    Singleton() { std::cout << "Singleton Created\n"; } // 构造私有
    ~Singleton() { std::cout << "Singleton Destroyed\n"; }

    Singleton(const Singleton&) = delete;               // 禁止拷贝
    Singleton& operator=(const Singleton&) = delete;    // 禁止赋值

public:
    static Singleton& getInstance() {
        static Singleton instance;  // 第一次调用时创建，C++11线程安全
        return instance;
    }

    void show() {
        std::cout << "Hello Lazy Singleton!" << std::endl;
    }
};

int main() {
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();

    s1.show();
    std::cout << "s1 addr = " << &s1 << ", s2 addr = " << &s2 << std::endl;

    return 0;
}

输出结果：

懒汉式的多线程安全写法（C++11 前）

如果在 C++11 之前，需要手动加锁防止多线程同时创建多个实例：

cpp 复制代码

#include <mutex>

class Singleton {
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* instance;
    static std::mutex mtx;

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }
};

// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;