C++实现Singleton模式

单例模式定义：保证一个类仅有一个实例，并提供一个该实例的全局访问点。

类的声明：

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

Singleton * Singleton::m_instance = nullptr;

解法1：线程非安全版本

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

解法2：线程安全版本，但锁的代价过高

Singleton* Singleton::getInstance()
{
	Lock lock;
	if(m_instance == nullptr)
	{
		m_instance = new Singleton();
	}
	return m_instance;
}

解析：当m_instance不为空时，加锁时不必要的，此时是在进行读操作。

解法3：双检查锁，但由于内存读写reorder不安全

Singleton* Singleton::getInstance()
{
	if(m_instance == nullptr)
	{
		Lock lock;
		if(m_instance == nullptr)
		{
			m_instance = new Singleton();
		}
	}
	return m_instance;
}

解析：m_instance = new Singleton()，1）、先分配内存，2）、调用构造器，3）、返回分配内存的地址。
存在这样一种情况：1）3）2）的执行顺序，当执行了1）3）后，m_instance不为空，直接就return m_instance了。

解法4：C++11版本之后的跨平台实现（volatile）

std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::get_instance()
{
	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;
}