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

单例模式

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

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

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

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

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

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

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

实现示例：

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

cpp 复制代码

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

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

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

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

cpp 复制代码

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），确保同一时间只有一个线程可以执行实例创建逻辑。

cpp 复制代码

#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，以避免不必要的锁开销。

cpp 复制代码

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

cpp 复制代码

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）来管理单例对象的生命周期，可以减少内存管理的复杂性。

cpp 复制代码

#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. 嵌套类与内存管理

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

cpp 复制代码

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对象

4. UML 图

UML 图解析

通过私有构造函数和静态成员变量 m_instance，确保 GameConfig 类只有一个实例。
通过公共静态方法 getInstance() 提供全局访问点，允许外部代码获取该实例。
将构造函数和实例变量设为私有，增强了类的封装性，避免了外部对实例的直接操作。

优缺点

优点：

唯一性：确保类只有一个实例，避免资源的重复分配。
全局访问：提供全局访问点，使得共享资源的管理更加方便。
延迟实例化：可以实现懒加载，只有在需要时才创建实例，节省资源。

缺点：

全局状态：可能导致全局状态的引入，增加系统的耦合性。
难以测试：使得单元测试变得困难，因为单例对象的创建和销毁不够灵活。
多线程问题：在多线程环境下实现复杂，可能引入性能开销和竞态条件。

适用场景

资源共享：适用于需要控制资源的共享，例如配置管理、日志记录和数据库连接等场景。
全局状态管理：适合需要全局访问的状态信息，如应用程序设置、游戏配置等。
限制实例数量：在程序生命周期内只需一个实例的场景，例如线程池、缓存管理和服务注册中心。
懒加载需求：当实例创建较为昂贵且不一定每次都需要时，适合使用懒加载策略。
跨模块访问：需要在多个模块或类中共享同一实例的情况，提升系统的统一性和一致性。

总结

单例模式是一种常用的设计模式，能够有效管理全局资源和状态。通过合理的实现方式，可以避免内存泄漏和多线程问题。理解单例模式的优缺点及适用场景，有助于在实际开发中正确应用这一模式。