设计模式——针对典型场景所设计出来的特别的处理方案
单例模式：一个类只能实例化一个对象（所以叫单例）
场景：
1、资源角度：资源在内存中只占有一份
2、数据角度：如果只有一个对象，那么该对象在什么时候访问它的资源都是一致的
目录
实现方式
一、饿汉模式
二、懒汉模式
就比如任务管理器，我再怎么重复打开它，它也只有这一份任务管理器。
实现方式
一、饿汉模式
所谓饿汉模式，直接将对象实例化完毕，用的时候直接就使用了（空间换时间）
好处：效率最大化，资源用的时候直接就用了（不涉及线程安全问题）
缺点：初始化速度慢，占用内存多
实现：使用静态成员变量（保证它在初始化就能有一份内存）
将构造函数私有化（类外无法实例化对象，对象只能有一份）
提供public接口进行访问
#include <iostream>
class Singleton
{
private:
int _data;
private:
static Singleton eton;
Singleton() // 将构造函数私有化，意味着在类外无法实例化对象
{ // 保证一个类只能实例化一个对象（构造函数私有化，该类也无法被继承）
// 逻辑处理begin
_data = 100;
// 逻辑处理end
}
public:
static Singleton *GetInstence() // 静态成员只能被静态成员函数调用
{
return &eton;
}
int Get_data() // 提供一个获取data的方法
{
return _data;
}
};
// 静态成员变量，类内声明、类外定义
Singleton Singleton::eton;
int main()
{
Singleton *eton = Singleton::GetInstence();
std::cout << eton->Get_data() << std::endl;
return 0;
}二、懒汉模式
所谓懒汉模式，就是等待用的时候才去进行构造，才去进行实例化
优点：内存资源占用少，初始化效率高
缺点：需要访问资源的时候需要去实例化对象加载（第一次访问时对象时比较慢）（涉及线程安全问题）
实现：
1、构造函数私有化（保证只能实例化一个对象）
2、定义静态类型的指针，在用的时候进行new
3、new的时候注意线程安全问题（加锁保护）
4、避免已经实例化之后后续资源重复加解锁访问（double check）
5、使用volatile修饰，避免编译器过度优化
volatile：当一个变量经常被cpu访问，那就把这个变量放入一个寄存器中，这样对于这样一个高频访问的变量，cpu就可以直接从寄存器中访问，避免了来回从内存中拿取数据。
#include <iostream>
#include <mutex>
class Singleton
{
private:
int _data;
private:
static Singleton *_eton; // 1、定义静态的指针与锁
static std::mutex _mutex;
Singleton() /// 2、构造函数私有化（只能被实例化一次）
{
// 逻辑处理begin
_data = 100;
// 逻辑处理end
}
public:
int get_data() { return _data; }
static Singleton *GetInsetnce()
{
if (_eton == nullptr) // 5、double check避免了已经实例化了还需要加解锁问题
{
_mutex.lock(); /// 4、使用mutex进行安全控制
if (_eton == nullptr)
_eton = new Singleton; // 3、等到用的时候进行new 调用构造实例化
_mutex.unlock();
}
return _eton;
}
};
// 6、对其构造和声明使用volatile修饰 保证数据的可见性
// volatile Singleton *Singleton::_eton = nullptr;
Singleton *Singleton::_eton = nullptr;
std::mutex Singleton::_mutex;
int main()
{
Singleton *eton = Singleton::GetInsetnce();
std::cout << eton->get_data() << std::endl;
}
