C++11中的call_once/once_flag使用

        为了保证在多线程环境中某个函数仅被调用一次，比如，需要初始化某个对象，而这个对象只能初始化一次，就可以用std::call_once来保证在多线程环境中只被调用一次。使用std::call_once是，需要一个once_flag作为call_once的入参，它的用法比较简单。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

template <typename T>
class Singleton
{
public:
	template<typename... Args>
		static T* Instance(Args&&... args)
		{
			if (m_pInstance == nullptr)
				m_pInstance = new T(std::forward<Args>(args)...);

			return m_pInstance;
		}

	static T* GetInstance()
	{
		if (m_pInstance == nullptr)
			throw std::logic_error("the instance is not init, please initialize the instance first");

		return m_pInstance;
	}

	static void DestroyInstance()
	{
		delete m_pInstance;
		m_pInstance = nullptr;
	}

private:
	Singleton(void);
	virtual ~Singleton(void);
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
private:
	static T* m_pInstance;
};

template <class T> T* Singleton<T>::m_pInstance = nullptr;

class CObject
{
public:
	CObject()
	{
		cout << "CObject construct...." << endl;
	};
	~CObject()
	{
		cout << "CObject destory ..." << endl;
	};

	void start()
	{
		cout << "....start....." << endl;
	}
};

std::once_flag flag;

void do_once()
{
	std::call_once(flag, [](){Singleton<CObject>::Instance();});
}

int main()
{
	{
		///先确保单利构造成功
		thread t1(do_once);
		thread t2(do_once);
		thread t3(do_once);

		t1.join();
		t2.join();
		t3.join();

		Singleton<CObject>::Instance()->start();
	}


	return 0;
}