（五）Head first design patterns单例模式（c++）

单例模式

单例模式的实现目的是：在整个系统的生命周期里，确保某些类只能实例化出一个实例对象。

单例模式的应用场景：操作系统任务管理器、windows系统的回收站、应用程序的日志、多线程的线程池……

单例模式又分为懒汉式和饿汉式，两者的区别仅在于创建此单例的时间不同。

懒汉式：程序开始运行时此单例并不存在，只在需要该单例的时候创建此单例。因为是在运行过程中创建单例，需要考虑线程安全问题。

饿汉式：单例在程序开始运行时就创建单例。这种创建方法本身就线程安全，不需要考虑多线程的线程安全问题。

懒汉式

实例一：用单线程去实现单例模式

//1. 单线程实现
class Singleton{
public:
    static Singleton* getInstance()
    {
        static Singleton* _instance;
        if(_instance == nullptr)
            _instance = new Singleton();
        return _instance;
    }
private:
    Singleton() = default;
};

其中new Singleton的过程分为三步：1）为Singleton对象开辟相应的内存空间。2）在开辟的内存空间中构造对象。3）完成构造之后用_instance指针指向内存空间。上面的例子对于单线程实现是没有问题的，但是对于多线程，假设线程A和线程B同时去竞争生成单例模式。A线程进来发现_instance==nullptr，于是进行步骤1）步骤2），此时B线程进来发现依_instance==nullptr，于是也去进行步骤1）和步骤2），这就违背了单例原则。于是对需要进行原子操作的部分进行加锁。

实例二：用加锁的方式去实现多线程的单例模式

// 多线程实现
#include <iostream>
using namespace std;
mutex mt;
class Singleton{
public:
    static Singleton* getInstance()
    {
        static Singleton* _instance;
        mt.lock();
        if(_instance == nullptr)
            _instance = new Singleton();
        mt.unlock();
        return _instance;
    }
private:
    Singleton() = default;
};

每个线程进入到getInstance都需要进行加锁动作，浪费了运行资源。于是在外层加一道判断，如果已经实例好了就可以直接跳过。

// 多线程实现
#include <iostream>
using namespace std;
mutex mt;
class Singleton{
public:
    static Singleton* getInstance()
    {
        static Singleton* _instance;
        if (_instance == nullptr ){
            mt.lock();
            if(_instance == nullptr)
                _instance = new Singleton();
            mt.unlock();
        }
        return _instance;
    }
private:
    Singleton() = default;
};

但是注意这种情况在发生了异常的情况下还是会有问题，new Singleton的三个步骤在计算机中可能是乱序执行的，有可能步骤3）执行完了再去执行步骤2），结果步骤2）发生了意外线程A被挂起。这个时候_instance已经指向了这部分空间，然后线程B判断_instance不为空……

实力三：直接使用静态局部变量去实现懒汉模式

#include <iostream>
using namespace std;
class Singleton{
public:
    static Singleton& getInstance()
    {
        static Singleton _instance;
        std::cout << &_instance << std::endl;
        return _instance;
    }
private:
    Singleton(){ std::cout << "Singleton construct." << std::endl; };
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
};
int main(){
    std::cout << "Run the main()" << std::endl;
    Singleton &s = Singleton::getInstance();
    Singleton &s1 = Singleton::getInstance();
    std::cout << &s << std::endl;
    std::cout << &s1 << std::endl; 
    return 0;
}
//Run the main()
//Singleton construct.
//0x104864000
//0x104864000
//0x104864000
//0x104864000

静态局部变量内存分配在全局区域，直到程序运行结束才会释放内存。静态局部变量只在第一次调用的时候才被实例化出来，而且只初始化一次。因此使用静态局部变量的方式具有线程安全特性。

饿汉式

饿汉式单例在程序开始运行时就被初始化出来了，不存在线程安全问题。

// 饿汉式
#include <iostream>
using namespace std;
class Singleton{
public:
    static Singleton* getInstance()
    {
        return p;
    }
private:
    Singleton(){ std::cout << "Singleton construct." << std::endl; };
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    static Singleton* p;
};
Singleton* Singleton::p = new Singleton();
int main(){
    std::cout << "Run the main()" << std::endl;
    Singleton* s = Singleton::getInstance();
    Singleton* s1 = Singleton::getInstance();
    return 0;
}
//Singleton construct.
//Run the main()

参考

 ​​​​​​​单例模式——C++实现_单例模式c++实现-CSDN博客

 C++单例模式实现_单例模式c++实现-CSDN博客