简介

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID（序号）生成器。
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。
一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

  1. #include <iostream>
  3. using namespace std;
  5. class Singleton {
  6.    static Singleton *instance;
  7.    int data;
  9.    // Private constructor so that no objects can be created.
  10.    Singleton() {
  11.       data = 0;
  12.    }
  14.    public:
  15.    static Singleton *getInstance() {
  16.       if (!instance)
  17.       instance = new Singleton;
  18.       return instance;
  19.    }
  21.    int getData() const{
  22.       return this -> data;
  23.    }
  25.    void setData(int data) {
  26.       this -> data = data;
  27.    }
  28. };
  30. //Initialize pointer to zero so that it can be initialized in first call to getInstance
  31. Singleton *Singleton::instance = 0;
  33. int main(){
  34.    Singleton *s = s->getInstance();
  35.    cout << s->getData() << endl;
  36.    s->setData(100);
  37.    cout << s->getData() << endl;
  38.    return 0;
  39. }

单例模式(Singleton Pattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
单例模式的要点有三个

  • 某个类只能有一个实例；
  • 它必须自行创建这个实例；
  • 必须自行向整个系统提供这个实例。

单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。

单例模式的优点总结来说：

  • 它能够避免对象重复创建，节约空间并提升效率
  • 避免由于操作不同实例导致的逻辑错误

单例模式实现有两种形式：懒汉式和饿汉式

不提倡使用懒加载方式，因为程序应该将构建与使用想分离，达到解耦。

模式结构

单例模式仅包含Singleton单例这一个角色
单例模式 - 图1

时序图

单例模式 - 图2

代码实现

  1. class Singleton
  2. {
  3.     public:
  4.     static Singleton* Instance()
  5.     {
  6.         if(instance == NULL)
  7.         {
  8.             Lock lock; //基于作用域的加锁，超出作用域，自动调用析构函数解锁
  9.             if(instance == NULL)
  10.             {
  11.                 instance_ == new Singleton();
  12.             }
  13.         }
  15.         return instance;
  16.     }
  18.     private:
  19.     static Singleton *instance;
  21.     Singleton();
  22.     ~Singleton();
  23.     Singleton(const Singleton&);
  24.     Singleton& operator=(const Singleton&);
  25. }
  27. Singleton *Singleton::instance = 0;

C++中需要将所有的显式和隐式的构造函数都作为private才可以

模式分析

单例模式的目的是保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式包含的角色只有一个，就是单例类——Singleton。单例类拥有一个私有构造函数，确保用户无法通过new关键字直接实例化它。除此之外，该模式中包含一个静态私有成员变量与静态公有的工厂方法，该工厂方法负责检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建。
在单例模式的实现过程中，需要注意如下三点：

  • 单例类的构造函数为私有；
  • 提供一个自身的静态私有成员变量；
  • 提供一个公有的静态工厂方法。

拓展资料

懒汉式

  1. public class Singleton {
  2.     private static Singleton instance = null;
  4.     private Singleton() {
  5.     }
  7.     public static Singleton getInstance(){
  8.         if(instance == null)
  9.             instance = new Singleton();
  10.     }
  11.     return instance
  12. }

饿汉式

  1. public class Singleton {
  2.     private static Singleton instance = null;
  4.     private Singleton() {
  5.     }
  7.     public static Singleton getInstance() {
  8.         synchronized(Singleton.class) {
  9.             if(instane == null) {
  10.                 instance = new Singleton()
  11.             }
  12.         }
  13.     }
  14. }

懒加载方式在平时非常常见，比如所使用的美团，支付宝等，应用首页会立刻刷新出来，但其他标签页在我们点击到才会刷新。这样就减少懒流量消耗，并缩短了程序启动时间。

参考资料

https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/singleton.html