设计模式——单例模式

什么是单例模式

一个类只能创建一个对象，即单例模式，该模式下可包管系统中该类只有一个实例，并提供一个访问它的全局接口，该实例被所有程序模块共享。
单例模式有两种实例环境

• 饿汉模式：程序启动就创建一个唯一的实例对象
  
• 懒汉模式：调佣全局接口的时候创建唯一的实例。
  

饿汉模式

1. class Singleton
2. {
3. public:
4.         static Singleton* GetInstance()
5.         {
6.                 return _ins;
7.         }
9.         void Add(const string& str)
10.         {
11.                 _mtx.lock();
13.                 _v.push_back(str);
15.                 _mtx.unlock();
16.         }
18.         void Print()
19.         {
20.                 _mtx.lock();
22.                 for (auto& e : _v)
23.                 {
24.                         cout << e << endl;
25.                 }
26.                 cout << endl;
28.                 _mtx.unlock();
29.         }
31. private:
32.         //限制类外随意创建对象
33.         Singleton()
34.         {
36.         }
38. private:
39.         int _n;
40.         vector<string> _v;
41.         mutex _mtx;
43.         static Singleton* _ins;
44. };
46. Singleton* Singleton::_ins = new Singleton;

复制代码

但是饿汉有一个题目：如果单例对象非常耗时或者占用很多资源，好比加载插件，初始化网络毗连，也有大概在程序一开始用不到，那么在程序一开始创建就会导致程序启动很慢，所以有了懒汉模式。
懒汉模式

1. class Singleton
2. {
3. public:
4.         static Singleton* GetInstance()
5.         {
6.                 //双检查加锁
7.                 if (_ins == nullptr) //提高效率，不需要每次加锁和解锁
8.                 {
9.                         _imtx.lock();
10.                        
11.                         if (_ins == nullptr) //保证线程安全,只用new一次
12.                         {
13.                                 _ins = new Singleton;
14.                         }
16.                         _imtx.unlock();
17.                 }
19.                 return _ins;
20.         }
22.         void Add(const string& str)
23.         {
24.                 _vmtx.lock();
26.                 _v.push_back(str);
28.                 _vmtx.unlock();
29.         }
31.         void Print()
32.         {
33.                 _vmtx.lock();
35.                 for (auto& e : _v)
36.                 {
37.                         cout << e << endl;
38.                 }
39.                 cout << endl;
41.                 _vmtx.unlock();
42.         }
44. private:
45.         //限制类外随意创建对象
46.         Singleton()
47.         {
49.         }
51. private:
52.         int _n;
53.         vector<string> _v;
54.         mutex _vmtx;
56.         static mutex _imtx;
57.         static Singleton* _ins;
58. };
60. Singleton* Singleton::_ins = nullptr;
61. mutex Singleton::_imtx;

复制代码

这里留意一下，创建实例的时候要用双重加锁，由于在多线程的场景下，就去一直加锁判断，要知道锁的斲丧是很大的，所以双重查抄是很紧张的。
懒汉模式的优点：

• 第一次使用的时候创建实例对象
  
• 如果多个单例对象有启动次序要求的话，也可以控制（这点饿汉模式就无法控制了）
  

懒汉模式的缺点

• 复杂
  

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