C++ 设计模式——单例模式

news2024/9/19 15:08:23

单例模式

- C++ 设计模式——单例模式
- - 1. 单例模式的基本概念与实现
  - 2. 多线程环境中的问题
  - 3. 内存管理问题
  - - 1. 内存泄漏风险
    - 2. 自动释放策略
    - 3. 垃圾回收机制
    - 4. 嵌套类与内存管理
  - 4. UML 图
  - - UML 图解析
  - 优缺点
  - 适用场景
  - 总结

C++ 设计模式——单例模式

单例模式（Singleton Pattern）也称单件模式/单态模式，是一种创建型模式，用于创建只能产生一个对象实例的类。

引入“单例”设计模式的定义（实现意图）：保证一个类仅有一个实例存在同时提供能对该实例访问的全局方法（getInstance 成员函数）。

1. 单例模式的基本概念与实现

单例模式通过以下几个关键点实现其目标：

唯一性：利用私有构造函数和静态成员变量，防止外部直接创建类的实例。
全局访问：提供一个公共静态方法（通常命名为 getInstance()），以确保所有调用者都能获取到相同的实例。
懒加载与饿加载：可以选择在类加载时（饿汉式）或首次调用时（懒汉式）创建实例。

实现示例：

饿汉式：在类加载时就创建实例，适合对内存占用不敏感的场景。

class GameConfig {
private:
    GameConfig() {};
    static GameConfig* m_instance;

public:
    static GameConfig* getInstance() {
        return m_instance;
    }
};

GameConfig* GameConfig::m_instance = new GameConfig();

懒汉式：在首次调用时创建实例，适合资源密集型对象。

class GameConfig {
private:
    GameConfig() {};
    static GameConfig* m_instance;

public:
    static GameConfig* getInstance() {
        if (m_instance == nullptr) {
            m_instance = new GameConfig();
        }
        return m_instance;
    }
};

GameConfig* GameConfig::m_instance = nullptr;

2. 多线程环境中的问题

在多线程环境中，懒汉式单例模式可能出现以下问题：

竞态条件：多个线程同时检查实例是否为 nullptr，可能导致多个线程同时创建实例，从而破坏单例特性。
资源浪费：若多个实例被创建，会导致内存和资源的浪费，影响系统性能和稳定性。

解决方案：

加锁：在创建实例的代码段中使用互斥锁（如 std::mutex），确保同一时间只有一个线程可以执行实例创建逻辑。

#include <mutex>

class GameConfig {
private:
    GameConfig() {};
    static GameConfig* m_instance;
    static std::mutex m_mutex;

public:
    static GameConfig* getInstance() {
        std::lock_guard<std::mutex> lock(m_mutex); // 加锁
        if (m_instance == nullptr) {
            m_instance = new GameConfig();
        }
        return m_instance;
    }
};

GameConfig* GameConfig::m_instance = nullptr;
std::mutex GameConfig::m_mutex;

双重检查锁定：在加锁的同时，仍然检查实例是否为 nullptr，以避免不必要的锁开销。

static GameConfig* getInstance() {
    if (m_instance == nullptr) {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (m_instance == nullptr) {
            m_instance = new GameConfig();
        }
    }
    return m_instance;
}

3. 内存管理问题

单例模式中的内存管理至关重要，尤其是在使用动态分配内存时。以下是一些关键点：

1. 内存泄漏风险

动态分配：如果单例类的实例通过 new 创建，而在程序结束时没有释放内存，可能导致内存泄漏。
手动释放：通常需要提供一个方法（如 freeInstance()）来手动释放单例对象的内存。

2. 自动释放策略

使用局部静态变量：在 C++ 中，可以使用局部静态变量来创建单例实例。这种方式的优点是，局部静态变量在程序结束时会自动调用析构函数，释放内存。

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

public:
    static GameConfig& getInstance() {
        static GameConfig instance; // 自动管理生命周期
        return instance;
    }
};

3. 垃圾回收机制

智能指针：使用智能指针（如 std::unique_ptr 或 std::shared_ptr）来管理单例对象的生命周期，可以减少内存管理的复杂性。

#include <memory>

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

public:
    static std::shared_ptr<GameConfig> getInstance() {
        static std::shared_ptr<GameConfig> instance(new GameConfig());
        return instance;
    }
};

4. 嵌套类与内存管理

对于使用饿汉式实现的单例模式，可以引入嵌套类来处理内存释放，确保在程序结束时自动释放内存。

class GameConfig {
private:
    GameConfig() {};
    GameConfig(const GameConfig&) = delete;
    GameConfig& operator=(const GameConfig&) = delete;
    ~GameConfig() {}; // 私有析构函数

public:
    static GameConfig* getInstance() {
        return m_instance; // 返回静态实例
    }

private:
    static GameConfig* m_instance; // 指向单例对象的指针

    // 垃圾回收类
    class Garbo {
    public:
        ~Garbo() {
            if (GameConfig::m_instance != nullptr) {
                delete GameConfig::m_instance; // 释放内存
                GameConfig::m_instance = nullptr; // 避免悬空指针
            }
        }
    };

    static Garbo garboobj; // 静态Garbo对象
};

// 静态成员变量初始化
GameConfig* GameConfig::m_instance = new GameConfig(); // 在类外初始化
GameConfig::Garbo GameConfig::garboobj; // 创建Garbo对象