设计模式——单例模式

单例模式

参考https://blog.csdn.net/sinat_31135199/article/details/76635052
http://www.runoob.com/design-pattern/singleton-pattern.html

单例模式（Singleton Pattern）提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
应用实例：

1. Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的对象，所以所有文件的处理必须通过唯一的实例来进行
2. 一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
2. 避免对资源的多重占用，如写文件操作

缺点：
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1. 要求产生唯一序列号
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等

注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

实现

我们将创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。SingleObject 类提供了一个静态方法，供外界获取它的静态实例。
JAVA的几种实现见http://www.runoob.com/design-pattern/singleton-pattern.html
其中包括lazy loading分析，多线程安全分析，C++实现也可参考。以下实现一种**双检锁/双重校验锁（DCL，即double-checked locking）**形式

#include <iostream>
#include <mutex>
#include <thread>

using namespace std;

// 用互斥量构建枷锁类，之所以构建此类是因为如果在Singleton类中建立static的mutex成员，
// 无法在类外初始化，如果不加static又不能保证仅有一个对象，因此专门做一个类
class Lock{
private:
    mutex mtx;
public:
    void lock(){ mtx.lock(); }
    void unlock(){ mtx.unlock(); }
};

class Singleton{
private:
    Singleton(int thread_id);
    // 为什么要声明拷贝构造函数和operator=？这里应该不允许拷贝和赋值，赋值还能return *this ?
    Singleton(const Singleton &);
    Singleton & operator = (const Singleton &);

    int value;
public:
    // static mutex mtx; // getInstance要用，因此声明为静态
    // lock和Instance必须放在public中的原因：static数据成员需要在类外进行初始化
    static Lock* lock;
    static Singleton* Instance;
    // 静态成员函数，没有this指针，不能访问对象的非静态数据成员
    static Singleton* getInstance(int thread_id);
    
    int getValue();
    ~Singleton(); // 析构函数不写不行么？
};

Singleton::Singleton(int thread_id): value(thread_id){}
Singleton::Singleton(const Singleton &){}
Singleton& Singleton::operator = (const Singleton &){
    return *this;
}
Singleton::~Singleton(){}
Singleton* Singleton::Instance = NULL; // 涉及静态成员的用法，静态数据成员只能在类外初始化，因此只能为public成员
Lock* Singleton::lock = new Lock();
Singleton* Singleton::getInstance(int thread_id){
    if(Instance == NULL){
        // mtx.lock();
        lock->lock();
        if(Instance == NULL)
            Instance = new Singleton(thread_id);
        // mtx.unlock();
        lock->unlock();
    }
    return Instance;
}

int Singleton::getValue(){
    return value;
}

mutex iomtx;
void print_thread_id(int thread_id){
    Singleton* instance = Singleton::getInstance(thread_id);
    iomtx.lock();
    cout << "thread_id: " << thread_id << endl;
    cout << "Instance is created in thread: " << instance->getValue() << endl;
    iomtx.unlock();
}

int main(){
    thread threads[2];
    for(int i = 0; i < 2; i++){
        threads[i] = thread(print_thread_id, i);
    }
    for(auto & th : threads) th.join();
    return 0;
}

单例模式唯一实例为什么必须为静态：
单例模式实现过程如下：
　　首先，将该类的构造函数私有化（目的是禁止其他程序创建该类的对象）；
　　其次，在本类中自定义一个对象（既然禁止其他程序创建该类的对象，就要自己创建一个供程序使用，否则类就没法用，更不是单例）；
　　最后，提供一个可访问类自定义对象的类成员方法（对外提供该对象的访问方式）。

直白的讲就是，你不能用该类在其他地方创建对象，而是通过该类自身提供的方法访问类中的那个自定义对象。
那么问题的关键来了，程序调用类中方法只有两种方式，
①创建类的一个对象，用该对象去调用类中方法；
②使用类名直接调用类中方法，格式“类名::方法名()”；

上面说了，构造函数私有化后第一种情况就不能用，只能使用第二种方法。
而使用类名直接调用类中的方法，类中方法必须是静态static的，而静态方法不能访问非静态成员变量，因此类自定义的实例变量也必须是静态的
这就是单例模式唯一实例必须设置为静态的原因。