设计模式——单例模式（懒汉，饿汉）

1.单例模式：一个类不管创建多少对象，永远只能得到该类型一个对象的实例

​ 常用：日志模块，数据库模块

//饿汉：
class singleton
{
public:
	//用户可以通过该接口调用静态对象
	static singleton* getInstance(){//#3获取类的唯一实例对象的接口方法
	return &instance;
	}
	
private:
	static singleton instance; //#2定义一个唯一的类的实例对象
	singleton(){}//#1构造函数私有化
    singleton(const singleton&)=delete;
    singleton& operator=(const singleton&)=delete;
};
//懒汉：
class singleton
{
public:
	//用户可以通过该接口调用静态对象
	static singleton* getInstance(){//#3获取类的唯一实例对象的接口方法
		if（instance=nullptr){
            instance=new singleton();
        }
        return instance;
	}
	
private:
	static singleton* instance; //#2定义一个唯一的类的实例对象
	singleton(){}//#1构造函数私有化
    singleton(const singleton&)=delete;
    singleton& operator=(const singleton&)=delete;
};

饿汉式：还没有获取实例对象，实例对象已经产生了，一定是线程安全的

懒汉式：唯一的实例对象，直到第一次获取它的时候才产生

​ 是不是可重入函数呢？多线程环境下不会发送竞态条件

​ 怎么做到线程安全？

//懒汉线程安全：
std::mutex mtx;
class singleton
{
public:
	//用户可以通过该接口调用静态对象
	static singleton* getInstance(){//#3获取类的唯一实例对象的接口方法
        
		if（instance=nullptr){//锁+双重判断
			lock_guard<std::mutex>lock(mtx);
            if(instance==nullptr){
            	instance=new singleton();   
            }
        }
        return instance;
	}
	
private:
	static singleton*volatile instance; //#2定义一个唯一的类的实例对象
	singleton(){}//#1构造函数私有化
    singleton(const singleton&)=delete;
    singleton& operator=(const singleton&)=delete;
};

//懒汉线程安全：
std::mutex mtx;
class singleton
{
public:
	//用户可以通过该接口调用静态对象
	static singleton* getInstance(){//#3获取类的唯一实例对象的接口方法
		//函数静态局部变量的初始化，在汇编指令上已经自动添加了线程互斥指令了
		//g++ -o main main.cpp -g     gdb main
		static singleton instance; //#2定义一个唯一的类的实例对象
        return &instance;
	}
	
private:
	singleton(){}//#1构造函数私有化
    singleton(const singleton&)=delete;
    singleton& operator=(const singleton&)=delete;
};
//static 是第一次运行到它的时候才初始化，所以第二步也是也可以是懒汉式