C++单例模式详解

编程小能手@

已于 2025-05-29 14:29:45 修改

阅读量1k

点赞数 14

文章标签： c++ 单例模式

于 2025-05-27 17:27:43 首次发布

本文链接：https://blog.csdn.net/w148_1748/article/details/148261483

版权

概述 C++ 单例模式（SingletonPattern）是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。该模式常用于日志记录器、配置管理器、数据库连接池等场景。以下从实现方式、线程安全、内存管理等方面进行详细解析。

一、单例模式的核心要求

私有构造函数：防止外部通过 new 创建实例。
静态实例变量：存储类的唯一实例。
全局访问方法：提供获取实例的静态接口。
禁止拷贝和赋值：防止通过复制或赋值创建新实例。

二、常见实现方式

1. 懒汉式（Lazy Initialization）

特点：延迟实例化，首次使用时创建。
问题：线程不安全，多线程环境下可能创建多个实例。

class LazySingleton {
private:
    static LazySingleton* instance;  // 静态实例指针
    LazySingleton() = default;       // 私有构造函数
    ~LazySingleton() = default;
    LazySingleton(const LazySingleton&) = delete;             // 禁用拷贝构造
    LazySingleton& operator=(const LazySingleton&) = delete;  // 禁用赋值运算符

public:
    static LazySingleton* getInstance() {
        if (instance == nullptr) {  // 首次调用时创建实例
            instance = new LazySingleton();
        }
        return instance;
    }
};

// 静态成员变量需要在类外初始化
LazySingleton* LazySingleton::instance = nullptr;

2. 饿汉式（Eager Initialization）

特点：程序启动时立即创建实例，线程安全。
缺点：无论是否使用，实例都会被创建，可能浪费资源。

class EagerSingleton {
private:
    static EagerSingleton instance;  // 静态实例对象
    EagerSingleton() = default;
    ~EagerSingleton() = default;
    EagerSingleton(const EagerSingleton&) = delete;
    EagerSingleton& operator=(const EagerSingleton&) = delete;

public:
    static EagerSingleton& getInstance() {
        return instance;  // 直接返回已创建的实例
    }
};

// 类外初始化，程序启动时即创建实例
EagerSingleton EagerSingleton::instance;

3. 线程安全的懒汉式（双检锁模式，Double-Checked Locking）

特点：通过双重检查和互斥锁保证线程安全，减少锁竞争开销。

#include <mutex>
class ThreadSafeSingleton {
private:
    static ThreadSafeSingleton* instance;
    static std::mutex mutex_;
    ThreadSafeSingleton() = default;
    ~ThreadSafeSingleton() = default;
    ThreadSafeSingleton(const ThreadSafeSingleton&) = delete;
    ThreadSafeSingleton& operator=(const ThreadSafeSingleton&) = delete;

public:
    static ThreadSafeSingleton* getInstance() {
        if (instance == nullptr) {  // 第一次检查，无锁
            std::lock_guard<std::mutex> lock(mutex_);  // 加锁
            if (instance == nullptr) {  // 第二次检查，确保只创建一次
                instance = new ThreadSafeSingleton();
            }
        }
        return instance;
    }
};

ThreadSafeSingleton* ThreadSafeSingleton::instance = nullptr;
std::mutex ThreadSafeSingleton::mutex_;

4. Meyers’ Singleton（C++11 最佳实践）

特点：使用局部静态变量，线程安全（C++11 起），自动处理内存释放。

class MeyersSingleton {
private:
    MeyersSingleton() = default;
    ~MeyersSingleton() = default;
    MeyersSingleton(const MeyersSingleton&) = delete;
    MeyersSingleton& operator=(const MeyersSingleton&) = delete;

public:
    static MeyersSingleton& getInstance() {
        static MeyersSingleton instance;  // 局部静态变量，线程安全
        return instance;
    }
};

三、线程安全与内存管理

1. 线程安全分析

懒汉式：非线程安全，需手动加锁。
饿汉式：线程安全，由静态初始化保证。
双检锁模式：线程安全，但需注意内存模型（C++11 后通过 std::atomic 修复）。
Meyers’ Singleton：线程安全，C++11 标准保证静态变量初始化的原子性。

2. 内存泄漏问题

普通懒汉式：使用 new 创建实例，需手动 delete 或通过智能指针管理。
智能指针方案：

class SmartSingleton {
private:
    static std::unique_ptr<SmartSingleton> instance;
    SmartSingleton() = default;
    ~SmartSingleton() = default;
    SmartSingleton(const SmartSingleton&) = delete;
    SmartSingleton& operator=(const SmartSingleton&) = delete;

public:
    static SmartSingleton& getInstance() {
        if (instance == nullptr) {
            instance = std::make_unique<SmartSingleton>();
        }
        return *instance;
    }
};

std::unique_ptr<SmartSingleton> SmartSingleton::instance = nullptr;

3. 自动释放机制

静态对象：如 Meyers’ Singleton，程序结束时自动析构。
atexit 注册：在单例类中注册析构函数：

static void destroyInstance() {
    delete instance;
    instance = nullptr;
}

// 在 getInstance() 中首次创建实例时注册
std::atexit(destroyInstance);

四、单例模式的优缺点

优点

全局唯一实例：确保系统中只有一个实例，便于资源控制。
全局访问点：无需传递对象引用，直接通过静态方法访问。
延迟初始化（懒汉式）：按需创建，节省资源。

缺点

违反单一职责原则：类既要管理自身生命周期，又要提供业务功能。
难以测试：单例状态可能影响测试的独立性，Mock 实现困难。
多线程风险：若实现不当，易导致线程安全问题。
潜在内存泄漏：手动管理实例生命周期时需谨慎。

五、高级话题

1. 模板单例（通用实现）

template <typename T>
class Singleton {
protected:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static T& getInstance() {
        static T instance;
        return instance;
    }
};

// 使用示例
class MyClass : public Singleton<MyClass> {
    friend class Singleton<MyClass>;  // 允许基类访问构造函数
private:
    MyClass() = default;  // 私有构造函数
public:
    void doSomething() { /* ... */ }
};

2. 多线程下的性能优化

减少锁竞争：双检锁模式仅在首次创建时加锁。
无锁实现：C++11 后使用 std::atomic 和内存屏障：

std::atomic<Singleton*> Singleton::instance{nullptr};
std::mutex Singleton::mutex_;

Singleton* Singleton::getInstance() {
    Singleton* tmp = instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(mutex_);
        tmp = instance.load(std::memory_order_relaxed);
        if (tmp == nullptr) {
            tmp = new Singleton;
            std::atomic_thread_fence(std::memory_order_release);
            instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}

3. 单例与序列化

若单例类需支持序列化，需确保反序列化时不创建新实例：

class SerializableSingleton {
private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        // 序列化逻辑
    }

protected:
    SerializableSingleton() = default;

private:
    // 防止反序列化时创建新实例
    friend class boost::serialization::singleton;
    static SerializableSingleton& get_instance();
};