线程安全的单例模式

1.饿汉模式

//饿汉模式
template<class T>
class Singleton {
private:
	Singleton() {};
private:
	static T *m_instance;//静态成员需要类内声明，类外定义；
	Singleton(const Singleton&) {};//禁止拷贝
	Singleton& operator = (const Singleton&) {};//禁止赋值
public:
	static T* getInstance()
	{
		return m_instance;//静态成员函数没有this指针，只能访问静态成员，所以m_instance要声明为静态；
	}
};
template<class T>
T* Singleton<T>::m_instance = new T();

2.懒汉模式

//懒汉模式
template<class T>
class SingleTon {
private:
	SingleTon() {};
	SingleTon(const SingleTon&) {};
	SingleTon& operator=(const SingleTon&) {};
	static T* m_instance;
	static mutex mtx;
public:
	static T* getInstance()
	{
		if (m_instance == nullptr)
		{
			mtx.lock();
			T *p = new T();//不直接m_instance=new T()，是为了防止new T()过程中返回了指针，
			m_instance = p; //但构造函数的初始化还没完成，而此时刚好有另一个线程访问了     
			mtx.unlock();
		}
		return m_instance;
	}
};
template<class T>
T* SingleTon<T>::m_instance = nullptr;
template<class T>
mutex SingleTon<T>::mtx;