单例模式 | LiuxiaoKun

单例模式：

一个类只能创建一个对象，该模式可以保证系统中只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

单例模式的要点有三个：

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

具体实现角度来说,就是以下三点:

单例模式的类只提供私有的构造函数
类定义中含有一个该类的静态私有对象
该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象

单例模式的优点:

在内存中只有一个对象,节省内存空间
避免频繁的创建销毁对象,可以提高性能
避免对共享资源的多重占用
可以全局访问

单例模式的适用场景:

需要频繁实例化然后销毁的对象
创建对象耗时过多或者耗资源过多,但又经常用到的对象
有状态的工具类对象
频繁访问数据库或文件的对象
以及其他要求只有一个对象的场景

单例模式的两种实现方式

饿汉式：就是说不管将来用不用，程序启动时就创建一个唯一的实例对象。
（如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。）

class Singleton
{
public:
    static Singleton* GetInstance()
    {
    return &m_instance;
    }
private:
    // 构造函数私有
    Singleton(){};
    // C++98 防拷贝
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    // or
    // C++11
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;
    static Singleton m_instance;
};
Singleton Singleton::m_instance; //

在程序入口之前就完成单例对象的初始化

懒汉式：如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，初始化网络连接啊，读取文件等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。所以这种情况使用懒汉模式（延迟加载）更好。

// 懒汉
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点：复杂
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
class Singleton
{
public:
static Singleton* GetInstance() {
// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
    if (nullptr == m_pInstance) {
        m_mtx.lock();
        if (nullptr == m_pInstance)
        {
            m_pInstance = new Singleton();
        }
        m_mtx.unlock();  
    }        
    return m_pInstance;
}
// 实现一个内嵌垃圾回收类
class CGarbo {
public:
    ~CGarbo(){
    if (Singleton::m_pInstance)
    delete Singleton::m_pInstance;
    }
};
    // 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
    static CGarbo Garbo;
private:
    // 构造函数私有
    Singleton(){};
    // 防拷贝
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    static Singleton* m_pInstance; // 单例对象指针
    static mutex m_mtx; //互斥锁
};
    Singleton* Singleton::m_pInstance = nullptr;
    Singleton::CGarbo Garbo;
    mutex Singleton::m_mtx;
void func(int n)
{
    cout<< Singleton::GetInstance() << endl;
}
// 多线程环境下演示上面GetInstance()加锁和不加锁的区别。
int main()
{
    thread t1(func, 10);
    thread t2(func, 10);
    t1.join();
    t2.join();
    cout << Singleton::GetInstance() << endl;
    cout << Singleton::GetInstance() << endl;
}