单例模式（Singleton Pattern）是设计模式中最简单的，主要是确保该类只有一个实例。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1、特点

  • 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

  • 避免一个全局使用的类频繁地创建与销毁。

    2、代码实现

    构造单例模式的步骤：

    1. 私有化构造函数，防止被外部函数直接实例化。
    2. 声明一个private static 的类指针，保存唯一的实例。
    3. 提供一个全局的static方法（全局访问点）。
    4. 该方法也返回单例类唯一的实例。

      懒汉式：

  • 在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢

是线程不安全的，考虑两个线程同时首次调用getInstance方法且同时检测到p是NULL值，则两个线程会同时构造一个实例给p，这是严重的错误！同时，这也不是单例的唯一实现！

  1. // 懒汉式，线程不安全
  2. class Singleton 
  3. {
  4. private:
  5.     Singleton(){};
  6.     static Singleton* instance;
  7. public:
  8.     static Singleton* getInstance() {
  9.         if (instance == nullptr) {
  10.             instance = new Singleton;
  11.         }
  12.         return instance;
  13.     }  
  14. }
  15. Singleton* Singleton::instance = 0;
  17. //懒汉式，加锁解决线程安全问题。
  18. class Singleton 
  19. {
  20. private:
  21.     Singleton(){
  22.         pthread_mutex_init(&mutex,NULL);
  23.     };
  24.     static Singleton* instance;
  25. public:
  26.     static pthread_mutex_t mutex;
  27.     static Singleton* getInstance() {
  28.         pthread_mutex_lock(&mutex);
  29.         if (instance == nullptr)
  30.             instance = new Singleton;
  31.         pthread_mutex_unlock(&mutex);
  32.         return instance;
  33.     }  
  34. }
  35. pthread_mutex_t Singleton::mutex;
  36. Singleton* Singleton::instance = 0;
  38. //懒汉式，可通过静态内部局部变量的方法解决线程安全问题。
  39. /*在getInstance函数里定义一个静态的实例，也可以保证拥有唯一实例，
  40.  *在返回时只需要返回其指针就可以。但是内存分配是在静态存储区，需要考量。
  41.  */
  42. class Singleton 
  43. {
  44. private:
  45.     Singleton(){};
  46. public:
  47.     // 使用指针而不是引用是为了避免拷贝构造函数进行拷贝
  48.     static Singleton* getInstance() {
  49.         static Singleton instance;
  50.         return &instance;
  51.     }  
  52. }
  54. int main()
  55. {
  56.     Singleton* p = Singleton::getInstance();
  57.     return 0;
  58. }

饿汉式：

  • 在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快

线程安全，类的静态成员变量，归该类所有成员，而非某个对象。

  1. //饿汉式，线程安全。
  2. class Singleton 
  3. {
  4. private:
  5.     Singleton(){};
  6.     static Singleton* instance;
  7. public:
  8.     static Singleton* getInstance() {
  9.         return instance;
  10.     }  
  11. }
  12. Singleton* Singleton::instance = new Singleton;
  13. int main()
  14. {
  15.     Singleton* p = Singleton::getInstance();
  16.     return 0;
  17. }

单例模板类 - 奇异递归模板（CRTP，The Curiously Recurring Template Pattern）模式

  1. template <typename TYPE>
  2. class Singleton {
  3. public：
  4.     static TYPE* getInstance() {
  5.         Mutex::Autolock _l(mLock);
  6.         if (instance == 0)
  7.             instance = new TYPE();
  8.         return instance;
  9.     }
  10. //构造函数需要是 protected，这样子类才能继承；
  11. protected:
  12.     Singleton(){};
  13.     ~Singleton(){};
  14. private:
  15.     static Mutex mLock;
  16.     static TYPE* instance;
  17. }
  18. template <typename TYPE> Mutex Singleton<TYPE>::mLock;
  19. template <typename TYPE> TYPE* Singleton<TYPE>::instance = 0;
  21. class ABCSingleton : public Singleton<ABCSingleton>
  22. {
  23. private:
  24.     //声明为友元，以便访问私有的构造和析构。
  25.     friend class Singleton<ABCSingleton>;       
  26. }

3、应用场景

  1. 由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。
  2. 在访问量较小时，采用懒汉实现。这是以时间换空间。
  3. factory 模式下，因为要包含很多实例，用饿汉模式。需要更多的空间，可考虑用懒汉模式。因为工厂模式缓存了很多实例、得考虑效率问题，因为这个类一加载则把所有实例一一创建

    4、参考链接

    面试中的Singleton: https://www.cnblogs.com/loveis715/archive/2012/07/18/2598409.html