怎样优雅地实现全局唯一？深入理解单例模式

怎样优雅地实现全局唯一？深入理解单例模式

一、什么是单例模式？

单例模式是一种创建型设计模式，旨在确保一个类只有一个实例，并为该实例提供全局访问点，从而制止全局变量的命名污染，并支持耽误初始化Wikipedia。
关键点:

• 私有构造函数（禁止外部new创建）
  
• 静态私有实例变量
  
• 静态公有获取方法
  

二、C++实现示例

1. #include<iostream>
2. using namespace std;
3. #if 0
4. // 饿汉模式 -> 定义类的时候创建单例对象
5. // 在多线程的场景下没用线程安全问题
6. // 线程安全：多线程同时访问单例模式
7. // 定义一个单例模式的任务队列
8. class TaskQueue
9. {
10. public:
11.     TaskQueue(const TaskQueue & t) = delete;
12.     TaskQueue& operator =(const TaskQueue& t) = delete;
13.     static TaskQueue *getInstance()
14.     {
15.         return m_taskQ;
16.     }
17.     void print()
18.     {
19.         cout<<"我是单例对象的一个成员函数..."<<endl;
20.     }
21. private:
22.     TaskQueue() = default;
23.     // 只能通过类名访问静态成员属性或方法
24.     static TaskQueue* m_taskQ;
25. };
26. TaskQueue* TaskQueue::m_taskQ = new TaskQueue;
27. #endif
29. #if 1
30. // 懒汉模式 -> 什么时候使用这个单例，再使用的时候再去创建对应的实例
31. // 在多线程的场景下可能存在线程安全问题
32. // 加互斥锁，让线程依次访问单例对象
33. // 比较节省内存空间
34. class TaskQueue
35. {
36. public:
37.     TaskQueue(const TaskQueue & t) = delete;
38.     TaskQueue& operator =(const TaskQueue& t) = delete;
39.     static TaskQueue *getInstance()
40.     {
41.         if(m_taskQ == nullptr)
42.         {
43.             m_taskQ = new TaskQueue;
44.         }
45.         return m_taskQ;
46.     }
47.     void print()
48.     {
49.         cout<<"我是单例对象的一个成员函数..."<<endl;
50.     }
51. private:
52.     TaskQueue() = default;
53.     //只能通过类名访问静态成员属性或方法
54.     static TaskQueue* m_taskQ;
55. };
56. TaskQueue* TaskQueue::m_taskQ = nullptr;
57. #endif
58. int main()
59. {
60.     TaskQueue* taskQ = TaskQueue::getInstance();
61.     taskQ->print();
62.     return 0;
63. }

复制代码

懒汉模式利用双重查抄锁定解决线程安全问题
问题原因：
多线程调用懒汉模式getInstance()，就会创建出多个TaskQueue的实例，违背单例模式的界说，所谓的单例就是只能有唯一的一个单例对象
解决方法：
1、互斥锁解决线程安全问题
互斥锁：制止同时访问，按顺序依次访问
利用原子变量解决双重查抄的问题：

1. //互斥锁头文件
2. #include<mutex>
3. ...
4.    mutex TaskQueue::m_mutex;
5. ...
6.    static mutex m_mutex;
7. ...
8.    static TaskQueue *getInstance()
9.     {
10.         if(m_taskQ == nullptr)//第一次检查
11.         {
12.             //进行加锁操作
13.             m_mutex.lock();
14.             if(m_taskQ == nullptr)//第二次检查
15.             {
16.                 m_taskQ = new TaskQueue;
17.             }
18.             //进行解锁操作 *注意*一个程序加锁之后一定要解锁，否则导致死锁
19.             m_mutex.unlock();
20.         }
21.         return m_taskQ;
22.     }
23. ...

复制代码

利用原子变量解决双重查抄的问题

1. //原子变量头文件
2. #include<atomic>
3. ...
4.    atomic<TaskQueue*> TaskQueue::m_taskQ = nullptr; //初始化
5. ...
6.    static atomic<TaskQueue*>m_taskQ;
7. ...
8.    static TaskQueue *getInstance()
9.     {
10.         TaskQueue* task = m_taskQ.load();
11.         if(task == nullptr)
12.         {
13.             m_mutex.lock();
14.             task = m_taskQ.load();//通过原子变量加载实例化指针
15.             if(task == nullptr)
16.             {
17.                 task = new TaskQueue;
18.                 m_taskQ.store(task);
19.             }
20.             m_mutex.unlock();
21.         }
22.         return task;
23.     }
24. ...

复制代码

2、局部静态对象解决线程安全问题

1. // 使用静态的局部对象解决线程安全问题 ->编译器支持C++11
2. ...
3. class TaskQueue
4. {
5. public:
6.     TaskQueue(const TaskQueue & t) = delete;
7.     TaskQueue& operator =(const TaskQueue& t) = delete;
8.     static TaskQueue *getInstance()
9.     {
10.         static TaskQueue task;
12.         return &task;
13.     }
14.     void print()
15.     {
16.         cout<<"我是单例对象的一个成员函数..."<<endl;
17.     }
18. private:
19.     TaskQueue() = default;
21. };
22. ...

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。