1.5 单例 Singleton

专业描述 单例模式让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。

真实世界类比 政府是单例模式的一个很好的示例。 一个国家只有一个官方政府。 不管组成政府的每个人的身份是什么， “某政府” 这一称谓总是鉴别那些掌权者的全局访问节点。

单例模式结构

1. 单例 （Singleton） 类声明了一个名为 get­Instance获取实例的静态方法来返回其所属类的一个相同实例。

• 单例的构造函数必须对客户端 （Client） 代码隐藏。 调用 获取实例方法必须是获取单例对象的唯一方式。

实现方法：

1. 在类中添加一个私有静态成员变量用于保存单例实例。
2. 声明一个公有静态构建方法用于获取单例实例。
3. 在静态方法中实现"延迟初始化"。 该方法会在首次被调用时创建一个新对象， 并将其存储在静态成员变量中。 此后该方法每次被调用时都返回该实例。
4. 将类的构造函数设为私有。 类的静态方法仍能调用构造函数， 但是其他对象不能调用。
5. 检查客户端代码， 将对单例的构造函数的调用替换为对其静态构建方法的调用。

单例模式可以分为：

1. 基础单例
2. 线程安全单例

线程安全C++算法概念示例：

#include<thread>
#include<mutex>
#include<iostream>
// using namespace std;
/**
 * The Singleton class defines the `GetInstance` method that serves as an
 * alternative to constructor and lets clients access the same instance of this
 * class over and over.
 */
class Singleton
{

    /**
     * The Singleton's constructor should always be private to prevent direct
     * construction calls with the `new` operator.
     */
private:
    static Singleton* singleton_;
    static std::mutex mutex_;
    Singleton(){}

protected:
    Singleton(const std::string value): value_(value){}
    ~Singleton(){}
    std::string value_;

public:

    /**
     * Singletons should not be cloneable.
     */
    Singleton(Singleton &other) = delete;
    /**
     * Singletons should not be assignable.
     */
    void operator=(const Singleton &) = delete;
    /**
     * This is the static method that controls the access to the singleton
     * instance. On the first run, it creates a singleton object and places it
     * into the static field. On subsequent runs, it returns the client existing
     * object stored in the static field.
     */

    static Singleton *GetInstance(const std::string& value);
    /**
     * Finally, any singleton should define some business logic, which can be
     * executed on its instance.
     */
    void SomeBusinessLogic()
    {
        // ...
    }

    std::string value() const{
        return value_;
    } 
};

Singleton* Singleton::singleton_= nullptr;;
std::mutex Singleton::mutex_;
/**
 * Static methods should be defined outside the class.
 */
Singleton *Singleton::GetInstance(const std::string& value)
{
    /**
     * This is a safer way to create an instance. instance = new Singleton is
     * dangeruous in case two instance threads wants to access at the same time
     */
    if(singleton_==nullptr){
        std::lock_guard<std::mutex> lock(mutex_);
        if (singleton_ == nullptr) {
          singleton_ = new Singleton(value);
        }
    }
    return singleton_;
}

void ThreadFoo(){
    // Following code emulates slow initialization.
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    Singleton* singleton = Singleton::GetInstance("FOO");
    std::cout << singleton->value() << "\n";
}

void ThreadBar(){
    // Following code emulates slow initialization.
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    Singleton* singleton = Singleton::GetInstance("BAR");
    std::cout << singleton->value() << "\n";
}

int main()
{
    std::cout <<"If you see the same value, then singleton was reused (yay!\n" <<
                "If you see different values, then 2 singletons were created (booo!!)\n\n" <<
                "RESULT:\n";   
    std::thread t1(ThreadFoo);
    std::thread t2(ThreadBar);
    t1.join();
    t2.join();

    return 0;
}

简单示例如下：

class Singleton {
 private:  // 将构造函数设为私有，让外界无法自己创建
  Singleton();
  Singleton(const Singleton &other);
  
  static Singleton *m_instance;

 public:
  static Singleton *getInstance();  // 通过 getInstance 方法获得 Singleton 实例
};

Singleton *Singleton::m_instance = nullptr;

std::mutex g_mutex;

Singleton *Singleton::getInstance() {
  if (m_instance == nullptr) {
    g_mutex.lock();
    if (m_instance == nullptr) {
      m_instance = new Singleton();
    }
    g_mutex.unlock();
  }
  return m_instance;
}

单例模式中唯一实例为什么要用静态？

这得从单例模式实现过程说起：

首先，将该类的构造函数私有化（目的是禁止其他程序创建该类的对象）；

其次，在本类中自定义一个对象（既然禁止其他程序创建该类的对象，就要自己创建一个供程序使用，否则类就没法用，更不是单例）；

最后，提供一个可访问类自定义对象的类成员方法（对外提供该对象的访问方式）。

说直白一点，你不能用该类在其他地方创建对象，而是通过该类自身提供的方法访问类中的那个自定义对象。

那么问题的关键来了，程序调用类中方法只有两种方式，①创建类的一个对象，用该对象去调用类中方法；②使用类名直接调用类中方法，格式“类名::方法名()”；

上面说了，构造函数私有化后第一种情况就不能用，只能使用第二种方法。

而使用类型直接点用类中的方法，类种方法必须是静态的，而静态方法不能访问非静态成员变量，因此类自定义的实例变量也必须是静态的。这就是单例模式唯一实例必须设置为静态的原因。