概述

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

一、单例模式的核心要求

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

二、常见实现方式

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);
  

四、单例模式的优缺点

优点

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

缺点

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

五、高级话题

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();
};

六、使用场景

1. 资源管理器：如文件系统、数据库连接池。
2. 配置管理：全局配置信息的读写。
3. 日志记录器：统一记录系统日志，避免多实例冲突。
4. GUI 应用：主窗口、对话框等通常设计为单例。

七、注意事项

1. 避免滥用：单例易导致全局状态，增加代码耦合度。
2. 多进程/分布式系统：单例仅在单个进程内有效，跨进程需使用其他机制（如共享内存、分布式锁）。
3. 继承与多态：单例类的子类可能破坏单例特性，需谨慎设计。

总结

C++ 单例模式的最佳实践推荐使用 Meyers’ Singleton（C++11 及以后），其简洁、线程安全且自动管理内存。对于旧版 C++ 或需要更复杂控制的场景，可采用双检锁模式并结合智能指针。无论选择哪种实现，都需注意线程安全、内存管理和代码可测试性。