C++ 单例模式的各种坑及最佳实践

单例模式是设计模式中最简单、常见的一种。其主要目的是确保整个进程中，只有一个类的实例，并且提供一个统一的访问接口。常用于 Logger 类、通信接口类等。

限制用户直接访问类的构造函数，提供一个统一的 public 接口获取单例对象。

(相关资料图)

这会有一个“先有鸡还是先有蛋”的问题：

解决这个问题的方法很简单，将 getInstance() 定义为 static 即可（这也会限制 getInstance() 内只能访问类的静态成员）

提前创建单例对象

class Singleton1 {   public:    static Singleton1* getInstance() { return &inst; }    Singleton1(const Singleton1&) = delete;    Singleton1& operator=(const Singleton1&) = delete;   private:    Singleton1() = default;    static Singleton1 inst;};Singleton1 Singleton1::inst;

这个版本在程序启动时创建单例对象，即使没有使用也会创建，浪费资源。

版本 2 通过将单例对象的实例化会推迟到首次调用 getInstance()，解决了上面的问题。

class Singleton2 {   public:    static Singleton2* getInstance() {        if (!pSingleton) {            pSingleton = new Singleton2();        }        return pSingleton;    }    Singleton2(const Singleton2&) = delete;    Singleton2& operator=(const Singleton2&) = delete;   private:    Singleton2() = default;    static Singleton2* pSingleton;};Singleton2* Singleton2::pSingleton = nullptr;

在版本 2 中，如果多个线程同时调用 getInstance() 则有可能创建多个实例。

class Singleton3 {   public:    static Singleton3* getInstance() {        lock_guard lck(mtx);        if (!pSingleton) {            pSingleton = new Singleton3();        }        return pSingleton;    }    Singleton3(const Singleton3&) = delete;    Singleton3& operator=(const Singleton3&) = delete;   private:    Singleton3() = default;    static Singleton3* pSingleton;    static mutex mtx;};Singleton3* Singleton3::pSingleton = nullptr;mutex Singleton3::mtx;

加锁可以解决线程安全的问题，但版本 3 的问题在于效率太低。每次调用 getInstance() 都需要加锁，而加锁的开销又是相当的高昂的。

版本 4 是版本 3 的改进版本，只有在指针为空的时候才会进行加锁，然后再次判断指针是否为空。而一旦首次初始化完成之后，指针不为空，则不再进行加锁。既保证了线程安全，又不会导致后续每次调用都产生锁的开销。

class Singleton4 {   public:    static Singleton4* getInstance() {        if (!pSingleton) {            lock_guard lck(mtx);            if (!pSingleton) {                pSingleton = new Singleton4();            }        }        return pSingleton;    }    Singleton4(const Singleton4&) = delete;    Singleton4& operator=(const Singleton4&) = delete;   private:    Singleton4() = default;    static Singleton4* pSingleton;    static mutex mtx;};Singleton4* Singleton4::pSingleton = nullptr;mutex Singleton4::mtx;

DCL 在很长一段时间内被认为是 C++ 单例模式的最佳实践。但也有文章表示 DCL 的正确性取决于内存模型，关于这部分的讨论可以参考这两篇文章：

这个版本利用局部静态变量来实现单例模式。最早由 C++ 大佬、Effective C++ 系列的作者 Scott Meyers 提出，因此也被称为 Meyers’ Singleton

"This approach is founded on C++"s guarantee that local static objects are initialized when the object"s definition is first encountered during a call to that function." ... "As a bonus, if you never call a function emulating a non-local static object, you never incur the cost of constructing and destructing the object."—— Scott Meyers

TLDR：这就是 C++11 之后的单例模式最佳实践，没有之一。

class Singleton5 {   public:    static Singleton5& getInstance() {        static Singleton5 inst;        return inst;    }    Singleton5(const Singleton5&) = delete;    Singleton5& operator=(const Singleton5&) = delete;   private:    Singleton5() = default;};

我曾见到过有人画蛇添足地返回单例指针，就像下面这样

static Singleton* getInstance() {    static Singleton inst;    return &inst;}

如果没什么正当的理由（我也实在想不到有什么理由），还是老老实实地返回引用吧。现代 C++ 应当避免使用裸指针，关于这一点，我也有一篇笔记：裸指针七宗罪