c++设计模式-单例模式

单例模式:

单例模式一般会分为:饿汉单例和懒汉单例

饿汉式: 在类加载的时候就完成初始化，所以类加载比较慢，但是获取对象的速度是比较快的．
懒汉式：在类加载的时候不初始化，等到第一次被使用的时候才进行初始化.

饿汉式:

class Singlenton{
	private:
		Singlenton() = default;
	    ~Singlenton() = default;
	 public:
	 	static  Singlenton & getInstance();
};
Singlenton &  Singlenton::getInstance(){
		static Singlenton c;
		return c;
}

饿汉式:

class Singlenton{
    private:
        Singlenton();
        Singlenton(const Singlenton &);
    public:
    static Singlenton * getInstance();
    static Singlenton* m_instance;
};

Singlenton * Singlenton::m_instance = nullptr;

Singlenton* Singlenton::getInstance() {
    if(m_instance == nullptr){
        m_instance = new Singlenton();
    }
    return m_instance;
}

这种方案对于多线程模式并不是安全的,有可能会同时创建多个对象
那么，我们肯定会随之进行加锁操作，但是在这里的话锁的代价过高

Singlenton* Singlenton::getInstance() {
 std::lock_guard<mutex> b(mutex_);
    if(m_instance == nullptr){
        m_instance = new Singlenton();
    }
    return m_instance;
    }

线程A没有释放锁，B无法进入,第一次之后，相当于多个线程仅仅是对这个地方进行读取,而对于多线程读的话是没有必要进行加锁,对于高并发的情况下，代价及其高昂
在这里我们可以使用双检查锁

Singlenton* Singlenton::getInstance() {
 if(m_instance == nullptr){
 //在执行这一行之前，有可能多个线程同时都执行到这一步
 std::lock_guard<mutex> b(mutex_);
    if(m_instance == nullptr){
        m_instance = new Singlenton();
    }
    }
    return m_instance;
    }

//消除代价过高的问题,对于上一次的缺陷进行完善
但是仍然有问题，内存读写reorder可能会造成不安全的情况
线程是在指令层级进行时间片的抢夺,cpu执行指令可能并不如我们之前的预期情况执行

std::atomic<Singlenton*> Singlenton::m_instance;
Singlenton* Singlenton::getInstance() {
	Singleton * temp = m_instance.load(std::memory_order_relaxed);
	//只保证在同一个线程内，同一个原子变量的操作的执行序列不会被重排序（reorder），这种保证也称之为modification order consistency，但是其他线程看到的这些操作的执行序列式不同的。
	std::atomic_thread_fence(std::memory_order_acquire); //获取内存的fence获取存储
 if(temp == nullptr){
 //在执行这一行之前，有可能多个线程同时都执行到这一步
 std::lock_guard<mutex> b(mutex_);
    if(temp== nullptr){
       temp = new Singlenton();
       std::atomic_thread_fence(std::memory_order_release); //释放内存fence
       m_instance.store(temp,std::memory_order_relaxed);
    }
    }
    return m_instance;
    }