释放双眼，带上耳机，听听看~！
简述
单例模式（Singleton Pattern）是设计模式中最简单的形式之一，其目的是使得类的一个对象成为系统中的唯一实例。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。
UML 结构图
要点
单例模式的要点有三个：
- 单例类有且仅有一个实例
- 单例类必须自行创建自己的唯一实例
- 单例类必须给所有其他对象提供这一实例
从具体实现角度来说，可分为以下三点：
- 提供一个 private 构造函数（防止外部调用而构造类的实例）
- 提供一个该类的 static private 对象
- 提供一个 static public 函数，用于创建或获取其本身的静态私有对象（例如：GetInstance()）
除此之外，还有一些关键点（需要多加注意，很容易忽视）：
- 线程安全（双检锁 – DCL，即：double-checked locking）
- 资源释放
局部静态变量
这种方式很常见，实现非常简单，而且无需担心单例的销毁问题。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2#ifndef SINGLETON_H
3#define SINGLETON_H
4
5// 非真正意义上的单例
6class Singleton
7{
8public:
9 static Singleton& GetInstance()
10 {
11 static Singleton instance;
12 return instance;
13 }
14
15private:
16 Singleton() {}
17};
18
19#endif // SINGLETON_H
20
但是，这并非真正意义上的单例。当使用如下方式访问单例时：
2
2
这会出现了一个类拷贝问题，从而违背了单例的特性。产生这个问题原因在于：编译器会生成一个默认的拷贝构造函数，来支持类的拷贝。
为了避免这个问题，有两种解决方式：
- 将 GetInstance() 函数的返回类型修改为指针，而非引用。
- 显式地声明类的拷贝构造函数，并重载赋值运算符。
对于第一种方式，只需要修改 GetInstance() 的返回类型即可：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2#ifndef SINGLETON_H
3#define SINGLETON_H
4
5// 单例
6class Singleton
7{
8public:
9 // 修改返回类型为指针类型
10 static Singleton* GetInstance()
11 {
12 static Singleton instance;
13 return &instance;
14 }
15
16private:
17 Singleton() {}
18};
19
20#endif // SINGLETON_H
21
既然编译器会生成一个默认的拷贝构造函数，那么，为什么不让编译器不这么干呢？这就产生了第二种方式：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
2#ifndef SINGLETON_H
3#define SINGLETON_H
4
5#include <iostream>
6
7using namespace std;
8
9// 单例
10class Singleton
11{
12public:
13 static Singleton& GetInstance()
14 {
15 static Singleton instance;
16 return instance;
17 }
18
19 void doSomething() {
20 cout << "Do something" << endl;
21 }
22
23private:
24 Singleton() {} // 构造函数（被保护）
25 Singleton(Singleton const &); // 无需实现
26 Singleton& operator = (const Singleton &); // 无需实现
27};
28
29#endif // SINGLETON_H
30
这样以来，既可以保证只存在一个实例，又不用考虑内存回收的问题。
2
3
2Singleton single = Singleton::GetInstance(); // Error 不能编译通过
3
懒汉式/饿汉式
在讲解之前，先看看 Singleton 的头文件（懒汉式/饿汉式公用）：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2#ifndef SINGLETON_H
3#define SINGLETON_H
4
5// 单例 - 懒汉式/饿汉式公用
6class Singleton
7{
8public:
9 static Singleton* GetInstance();
10
11private:
12 Singleton() {} // 构造函数（被保护）
13
14private:
15 static Singleton *m_pSingleton; // 指向单例对象的指针
16};
17
18#endif // SINGLETON_H
19
懒汉式的特点：
- Lazy 初始化
- 非多线程安全
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁（在“线程安全”部分分享如何加锁）才能保证单例，但加锁会影响效率。
2
3
4
5
6
7
8
9
10
11
12
13
14
2#include "singleton.h"
3
4// 单例 - 懒汉式
5Singleton *Singleton::m_pSingleton = NULL;
6
7Singleton *Singleton::GetInstance()
8{
9 if (m_pSingleton == NULL)
10 m_pSingleton = new Singleton();
11
12 return m_pSingleton;
13}
14
饿汉式的特点：
- 非 Lazy 初始化
- 多线程安全
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
2
3
4
5
6
7
8
9
10
11
2#include "singleton.h"
3
4// 单例 - 饿汉式
5Singleton *Singleton::m_pSingleton = new Singleton();
6
7Singleton *Singleton::GetInstance()
8{
9 return m_pSingleton;
10}
11
线程安全
在懒汉式下，如果使用多线程，会出现线程安全隐患。为了解决这个问题，可以引入双检锁 – DCL 机制。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2#ifndef SINGLETON_H
3#define SINGLETON_H
4
5#include <iostream>
6#include <mutex>
7using namespace std;
8
9// 单例 - 懒汉式/饿汉式公用
10class Singleton
11{
12public:
13 static Singleton* GetInstance();
14
15private:
16 Singleton() {} // 构造函数（被保护）
17
18private:
19 static Singleton *m_pSingleton; // 指向单例对象的指针
20 static mutex m_mutex; // 锁
21};
22
23#endif // SINGLETON_H
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2#include "singleton.h"
3
4// 单例 - 懒汉式（双检锁 DCL 机制）
5Singleton *Singleton::m_pSingleton = NULL;
6mutex Singleton::m_mutex;
7
8Singleton *Singleton::GetInstance()
9{
10 if (m_pSingleton == NULL) {
11 std::lock_guard<std::mutex> lock(m_mutex); // 自解锁
12 if (m_pSingleton == NULL) {
13 m_pSingleton = new Singleton();
14 }
15 }
16 return m_pSingleton;
17}
18
这样，就可以保证线程安全了，但是，会带来较小的性能影响。
资源释放
有内存申请，就要有对应的释放，可以采用下述两种方式：
- 主动释放（手动调用接口来释放资源）
- 自动释放（由程序自己释放）
要手动释放资源，添加一个 static 接口，编写需要释放资源的代码：
2
3
4
5
6
7
8
9
2static void DestoryInstance()
3{
4 if (m_pSingleton != NULL) {
5 delete m_pSingleton;
6 m_pSingleton = NULL;
7 }
8}
9
然后在需要释放的时候，手动调用该接口：
2
2
方式虽然简单，但很多时候，容易忘记调用 DestoryInstance()。这时，可以采用更方便的方式：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
2#ifndef SINGLETON_H
3#define SINGLETON_H
4
5#include <iostream>
6
7using namespace std;
8
9// 单例 - 自动释放
10class Singleton
11{
12public:
13 static Singleton* GetInstance();
14
15private:
16 Singleton() {} // 构造函数（被保护）
17
18private:
19 static Singleton *m_pSingleton; // 指向单例对象的指针
20
21 // GC 机制
22 class GC
23 {
24 public:
25 ~GC()
26 {
27 // 可以在这里销毁所有的资源，例如：db 连接、文件句柄等
28 if (m_pSingleton != NULL) {
29 cout << "Here destroy the m_pSingleton..." << endl;
30 delete m_pSingleton;
31 m_pSingleton = NULL;
32 }
33 }
34 static GC gc; // 用于释放单例
35 };
36};
37
38#endif // SINGLETON_H
39
只需要声明 Singleton::GC 即可：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2#include "singleton.h"
3
4Singleton::GC Singleton::GC::gc; // 重要
5
6int main()
7{
8 Singleton *pSingleton1 = Singleton::GetInstance();
9 Singleton *pSingleton2 = Singleton::GetInstance();
10
11 cout << (pSingleton1 == pSingleton2) << endl;
12
13 return 0;
14}
15
在程序运行结束时，系统会调用 Singleton 的静态成员 GC 的析构函数，该析构函数会进行资源的释放。这种方式的最大优点就是在“不知不觉”中进行，所以，对我们来说，尤为省心。
