单例模式

单例模式

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

	常用类型：
	日志模块，写日志信息，没有必要每次写日志就创建对象，占用内存
	数据库模块，数据库请求很多，没有必要每次生成一个数据库对象

	饿汉单例模式：还没有获取实例对象，实例对象就已经产生了
	懒汉单例模式：唯一实例对象，直到第一次获取它的时候，才产生

懒汉式单例模式

//饿汉式单例模式 一定是线程安全的 main 函数前初始化好，线程还没有启动
//控制类的个数，首先要控制构造函数，如果用户任意访问构造函数，就可以任意构建对象
class Singleton
{
public:
	//定义接口使得用户可以获取唯一的实例对象
	//普通成员方法的调用要依赖对象，所以需要静态成员方法
	//获取类唯一实例对象接口方法
	static Singleton* getInstance()
	{
		return &instance;
	}
private:
	//构造函数私有化
	Singleton()
	{
		//加载配置信息，读磁盘文件，访问数据库
		//如果整个项目没有使用到这个实例对象，那么就白费功夫，太多饿汉式就会加强函数启动时间
	}
	//拷贝构造私有化
	Singleton(const Singleton& val) = delete;
	//复制重载私有化
	Singleton& operator=(const Singleton& val) = delete;
	//静态成员变量要在类外初始化 定义一个唯一的类的实例对象
	static Singleton instance;
};

//静态成员变量 在数据段
Singleton Singleton::instance;

饿汉式线程所单例模式

//懒汉式单例模式 线程安全
class Singleton2
{
public:
	//如何是其变为可重入函数
	static Singleton2* getInstance()
	{
		//加锁 锁的粒度太大了 锁+双重判断
		//lock_guard<std::mutex> guard(mtx);
		if (instance == nullptr)
		{
			//只有第一次生成对象的时候加锁
			lock_guard<std::mutex> guard(mtx);
			/*
			临界区代码段 要做线程的互斥
			开辟内存 构造对象 给instance赋值
			编译器会进行顺序倒换来加速代码的执行
			开辟内存  给instance赋值 构造对象 
			只赋值，没构造，线程二进来发现instance不为空 直接返回了一个未经构造的对象
			*/
			if (instance == nullptr)
			{
				instance = new Singleton2();
			}

		}
		return instance;
	}
private:
	Singleton2(){}
	Singleton2(const Singleton2& val) = delete;
	Singleton2& operator=(const Singleton2& val) = delete;
	//线程CPUcache不对它进行缓存了
	static Singleton2* volatile instance;

};
static Singleton2* volatile instance = nullptr;

饿汉式静态对象单例模式

//懒汉式单例模式 线程安全 不用互斥锁
class Singleton3
{
public:
	//如何是其变为可重入函数
	static Singleton3* getInstance()
	{
		//第一次运行到静态变量的时候才初始化
		//函数静态局部变量的初始化，在汇编指令上已经自动添加线程互斥指令了
		static Singleton3 instance;
		
		return &instance;
	}
private:
	Singleton3() {}
	Singleton3(const Singleton3& val) = delete;
	Singleton3& operator=(const Singleton3& val) = delete;
	//线程CPUcache不对它进行缓存了
	static Singleton3* instance;

};
static Singleton3* instance = nullptr;