ToB企服应用市场:ToB评测及商务社交产业平台

标题: 设计模式——单例模式 [打印本页]
作者: 鼠扑    时间: 2024-8-12 22:33
标题: 设计模式——单例模式
什么是单例模式

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


饿汉模式

  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企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4