5 Singleton

自动关联目录:5 Singleton

单例保证一个类只有一个实例,并提供全局访问点。它是 23 个模式里唯一一个"默认不该用"的——它解决的从来不是设计问题,而是方便问题。

代价是明确的:全局状态、生命周期不可控、隐式依赖、测试之间互相污染。

形式

class Singleton {
public:
	static Singleton* GetInstance();
	static Singleton* m_Instance;
private:
	Singleton();
	Singleton(const Singleton& singleton);
};

三条要素:私有构造、静态实例、静态访问点。剩下所有复杂度都来自"线程安全"和"析构顺序"。

四种写法的演进

// 1. 线程不安全(懒汉)
Singleton* Singleton::GetInstance(){
	if (m_Instance != nullptr)
		return m_Instance;
	m_Instance = new Singleton();
	return m_Instance;
}

// 2. 线程安全,无脑加锁:每次调用都上锁,高频路径上是纯浪费
Singleton* Singleton::GetInstance(){
	Lock lock;
	...
}

// 3. 双检查锁(错误版):指令重排下,可能"指针已赋值但对象还没构造完"
Singleton* Singleton::GetInstance(){
	if (m_Instance != nullptr)
		return m_Instance;
	Lock lock;
	if (m_Instance != nullptr)
		return m_Instance;
	m_Instance = new Singleton();
	return m_Instance;
}

问题在 m_Instance = new Singleton() 这行,它实际是三步:分配内存 → 构造 → 赋值指针。编译器与 CPU 都可能重排成"分配 → 赋值 → 构造",于是另一个线程拿到非空指针,访问到的是还没构造完的对象。

// 4. 线程安全,双检查锁 + 原子与内存栅栏
std::atomic<Singleton*> Singleton::m_Instance;
std::mutex Singleton::m_Mutex;

Singleton* Singleton::GetInstance(){
	Singleton* tmp = m_Instance.load(std::memory_order_relaxed);
	std::atomic_thread_fence(std::memory_order_acquire);   // 保证后续读到的对象是构造完成的
	if (tmp != nullptr)
		return tmp;
	std::lock_guard<std::mutex> guard(m_Mutex);
	tmp = m_Instance.load(std::memory_order_relaxed);
	if (tmp != nullptr)
		return tmp;
	tmp = new Singleton();
	std::atomic_thread_fence(std::memory_order_release);  // 保证构造先于指针可见
	m_Instance.store(tmp, std::memory_order_relaxed);
	return tmp;
}

C++11 之后:别写上面那堆

函数内静态局部变量的初始化由语言保证线程安全(C++11 起,且只做一次):

class Singleton {
public:
    static Singleton& Get() {
        static Singleton instance;   // 线程安全,首次调用时构造
        return instance;
    }
    Singleton(const Singleton&)            = delete;
    Singleton& operator=(const Singleton&) = delete;
private:
    Singleton() = default;
};

优点:无锁、无堆分配、无需手写栅栏、程序结束时按构造逆序析构。这是 C++ 里单例的默认写法,前面那些讨论的价值在于理解"为什么需要栅栏",而不是照抄。

生命周期

问题说明
静态对象析构顺序跨编译单元的静态对象析构顺序未定义,单例 A 析构时用到已析构的 B 就会崩
泄漏式单例new 出来永不析构( intentional leak),规避析构顺序问题,代价是内存泄漏与不跑析构函数
依赖其他单例尽量让单例无依赖,或显式提供 Init() / Shutdown() 由主控流程调用

引擎里更常见的做法是显式生命周期:Initialize() / Shutdown() 由引擎启动与退出驱动,而不是靠静态对象的构造析构。

什么时候真的该用

适合不适合
日志(进程级唯一出口)"管理器"(多半只是懒得传参)
平台抽象层 / 内存分配器全局配置(应显式传参,方便测试换配置)
真正的硬件/进程级唯一资源业务对象(今天唯一,明天就要多开)

判断问题:"如果哪天需要两个,我会死得多惨?" 答案很惨就别用单例。

替代方案

方案说明
依赖注入构造时传进来,依赖写在签名上,测试可替换
上下文对象 / Subsystem由框架持有并分发,生命周期归框架管
命名空间级自由函数 + 局部状态不需要实例时就别造实例

常见坑

坑说明
单元测试之间互相污染全局状态在用例间残留,必须提供 Reset()
在 GetInstance() 里做重活首次调用时机不可控,可能造成卡顿
单例内部再依赖单例初始化顺序变成隐式契约
跨 DLL 边界每个模块各有一份实例,"唯一"失效
把它当成"全局变量的好听说法"那就是全局变量