C++设计模式（一）——单件模式（单例模式）

  该模式的核心思想是保证一个类仅有一个实例，并提供一个该实例的全局访问点。与工厂模式、建筑者模式、原型模式都是属于创建模式；

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

Singleton* Singleton::m_instance=nullptr;

//线程非安全版本
Singleton* Singleton::getInstance() 
{
    if (m_instance == nullptr)
	{
        m_instance = new Singleton();
    }
    return m_instance;
}

//线程安全版本，但锁的代价过高
Singleton* Singleton::getInstance()
{
    Lock lock;
    if (m_instance == nullptr) 
	{
        m_instance = new Singleton();
    }
    return m_instance;
}

//双检查锁，但由于内存读写reorder不安全
Singleton* Singleton::getInstance() 
{    
    if(m_instance==nullptr)
	{
        Lock lock;
        if (m_instance == nullptr) {
            m_instance = new Singleton();
        }
    }
    return m_instance;
}

//C++ 11版本之后的跨平台实现 (volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() 
{
    Singleton* tmp = m_instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(m_mutex);
        tmp = m_instance.load(std::memory_order_relaxed);
        if (tmp == nullptr) 
		{
            tmp = new Singleton;
            std::atomic_thread_fence(std::memory_order_release);//释放内存fence
            m_instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}

  在单件模式中，其构造思想是将构造函数作为私有成员函数，通过公有成员函数进行实例化返回；