Singleton单例模式

单例模式

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

实现模式：

1. 饿汉模式
2. 懒汉模式

• 饿汉模式

就是说不管你将来用不用，程序启动时就创建(静态的)一个(定义一个静态对象)唯一的实例对象

优缺点：

优点：简单

缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。

class Singleton
{
public:
    //只能按照引用的方式返回，因为拷贝构造函数调用不了
	Singleton& GetInstance()
	{
		return _ps;
	}
	
private:
    //构造函数私有
    Singleton() 
    {}
    //C++11中防拷贝
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;
    
    static Singleton _ps;
};

//在程序入口之前就完成对单例对象的初始化
static Singleton::_ps;

• 懒汉模式

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

优缺点：

优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。

缺点：复杂

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

class Singleton
{
public:
    //不能返回对象，不然的话对象已经存在，所以返回指针
    static Singleton* GetInstance()
    {
        if(nullptr == _ps)
        {
            _mutex.lock();
            if(nullptr == _ps)
            {
                //申请空间->构造对象->赋值
                _ps = new Singleton();
            }
            _mutex.unlock();
        }
        return _ps;
    }
    
    // 实现一个内嵌垃圾回收类
    class GC
    {
    public:
		~GC()
		{
			if (nullptr != _ps)
			{
				delete _ps;
				_ps = nullptr;
			}
		}
    };
    
private:
    Singleton()
    {}
    //防拷贝
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    
    //单例对象指针
    //volatile:禁止编译器对次序的优化（申请空间->构造对象->赋值）
    static Singleton* volatile _ps;
    //互斥锁
	static mutex _mutex;
	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static GC _gc;
};

Singleton* volatile Singleton::_ps = nullptr;
mutex Singleton::_mutex;
Singleton::GC _gc;
 
void func(int a)
{
	Singleton::GetInstance();
}

int main()
{
	thread t1(func, 10);
	thread t2(func, 10);
	t1.join();
	t2.join();
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;

	return 0;
}