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

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

限制用户直接访问类的构造函数，提供一个统一的 public 接口获取单例对象。
这里有一个“先有鸡还是先有蛋”的问题：

• 因为用户无法访问构造函数，所以无法创建对象
  
• 因为无法创建对象，所以不能调用普通的 getInstance() 方法来获取单例对象
  

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

• 所有的构造函数是 private 的
  
• 拷贝构造、拷贝赋值运算符需要显式删除 =delete，防止编译器自动合成（即使你显式定义了析构函数或拷贝构造/拷贝赋值运算符，编译器依然可能合成拷贝赋值运算符/拷贝构造！新的 C++ 标准已将该行为标记为 deprecated，但为了兼容旧代码，目前 C++23 仍然会合成！后面打算单独用一篇笔记总结一下编译器默认合成的函数）
  

C++ 单例模式的几种实现方式

版本 1 饿汉式

提前创建单例对象

1. class Singleton1 {
2.    public:
3.     static Singleton1* getInstance() { return &inst; }
4.     Singleton1(const Singleton1&) = delete;
5.     Singleton1& operator=(const Singleton1&) = delete;
7.    private:
8.     Singleton1() = default;
9.     static Singleton1 inst;
10. };
12. Singleton1 Singleton1::inst;

复制代码

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

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

1. class Singleton2 {
2.    public:
3.     static Singleton2* getInstance() {
4.         if (!pSingleton) {
5.             pSingleton = new Singleton2();
6.         }
7.         return pSingleton;
8.     }
9.     Singleton2(const Singleton2&) = delete;
10.     Singleton2& operator=(const Singleton2&) = delete;
12.    private:
13.     Singleton2() = default;
14.     static Singleton2* pSingleton;
15. };
17. Singleton2* Singleton2::pSingleton = nullptr;

复制代码

版本 3 线程安全

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

1. class Singleton3 {
2.    public:
3.     static Singleton3* getInstance() {
4.         lock_guard<mutex> lck(mtx);
5.         if (!pSingleton) {
6.             pSingleton = new Singleton3();
7.         }
8.         return pSingleton;
9.     }
10.     Singleton3(const Singleton3&) = delete;
11.     Singleton3& operator=(const Singleton3&) = delete;
13.    private:
14.     Singleton3() = default;
15.     static Singleton3* pSingleton;
16.     static mutex mtx;
17. };
19. Singleton3* Singleton3::pSingleton = nullptr;
20. mutex Singleton3::mtx;

复制代码

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

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

1. class Singleton4 {
2.    public:
3.     static Singleton4* getInstance() {
4.         if (!pSingleton) {
5.             lock_guard<mutex> lck(mtx);
6.             if (!pSingleton) {
7.                 pSingleton = new Singleton4();
8.             }
9.         }
10.         return pSingleton;
11.     }
12.     Singleton4(const Singleton4&) = delete;
13.     Singleton4& operator=(const Singleton4&) = delete;
15.    private:
16.     Singleton4() = default;
17.     static Singleton4* pSingleton;
18.     static mutex mtx;
19. };
21. Singleton4* Singleton4::pSingleton = nullptr;
22. mutex Singleton4::mtx;

复制代码

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

• https://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
  
• https://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/
  

版本 5 Meyers’ Singleton

这个版本利用局部静态变量来实现单例模式。最早由 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 之后的单例模式最佳实践，没有之一。

• 最简洁：不需要额外定义类的静态成员
  
• 线程安全，不需要额外加锁
  
• 没有烦人的指针
  

1. class Singleton5 {
2.    public:
3.     static Singleton5& getInstance() {
4.         static Singleton5 inst;
5.         return inst;
6.     }
8.     Singleton5(const Singleton5&) = delete;
9.     Singleton5& operator=(const Singleton5&) = delete;
11.    private:
12.     Singleton5() = default;
13. };

复制代码

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

1. static Singleton* getInstance() {
2.     static Singleton inst;
3.     return &inst;
4. }

复制代码

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

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！