單例模式(Singleton)-多線程安全

原文轉自： http://www.tanjp.com (即時修正和更新)

多線程安全的單例模式

 

單例模式，是一種常用的軟件設計模式。通過單例模式可以保證系統中，應用該模式的一個類型只有一個實例。

多線程環境下，建議使用 sptr() 獲得共享智能指針使得對象的釋放得以延伸到最後一個有效引用使用完。

各個類型的單例對象的作用域爲全局（類似全局變量），但同時可以確定變量初始化和釋放的時機（全局變量初始化和釋放是不可控）。

通過 call_once 可保證在整個進程生命週期內只會被初始化或釋放一次，重複調用 init 或者 release 都是無用的。

多線程安全的實現：

template< typename tpType, int tpKey = 0 >
class Singleton
{
public:
	template <typename... tpArgs>
	static void init(tpArgs&&... args)
	{
		std::call_once(msn_new, [&]() {
			msp_instance = std::shared_ptr<tpType>(new tpType(std::forward<tpArgs>(args)...));
		});
	}
	static void release()
	{
		std::call_once(msn_del, [&]() {	msp_instance.reset(); });
	}
	static tpType * ptr() {	return msp_instance.get(); }
	static std::shared_ptr<tpType> sptr() { return msp_instance; } //建議多線程環境下使用
protected:
	Singleton() = default;
	~Singleton() = default;
	Singleton(const Singleton&) = delete;
	Singleton(Singleton&&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	Singleton& operator=(Singleton&&) = delete;
private:
	static std::once_flag msn_new; //創建標記
	static std::once_flag msn_del; //釋放標記
	static std::shared_ptr<tpType> msp_instance;
};
// 以下是模版類靜態初始化
template<typename tpType, int tpKey>
std::once_flag Singleton<tpType, tpKey>::msn_new;
template<typename tpType, int tpKey>
std::once_flag Singleton<tpType, tpKey>::msn_del;
template<typename tpType, int tpKey>
std::shared_ptr<tpType> Singleton<tpType, tpKey>::msp_instance = std::shared_ptr<tpType>();

應用例子：

class TestTypeClass
	{
	public:
		TestTypeClass(const std::string & ps_str, uint32 pn_val)
			: ms_str(ps_str)
			, mn_val(pn_val) { }
		void print()
		{
    		std::cout << "string = " << ms_str << ", value = " << mn_val << std::endl;
   }
private:
	std::string ms_str;
	uint32 mn_val;
};
int main(int argc, char* argv[])
{		
    typedef Singleton<std::string, 1> GlobalStringA;
    GlobalStringA::init("string A");
    std::string * zp_str = GlobalStringA::ptr();
    if (zp_str)
    {
        std::cout << "GlobalStringA : " << zp_str->c_str() << std::endl;
    }
    GlobalStringA::release();
    
    typedef Singleton<uint32, 2> GlobalValueType;
    GlobalValueType::init(100);
    uint32 * zp_val = GlobalValueType::ptr();
    if (zp_val)
    {
        std::cout << "GlobalValueType : " << *zp_val << std::endl;
    }
    GlobalValueType::release();
    
    typedef Singleton<TestTypeClass, 3> GlobalClassType;
    GlobalClassType::init("class name", 99);
    TestTypeClass * zp_type_val = GlobalClassType::ptr();
    if (zp_type_val)
    {
        zp_type_val->print();
    }
    GlobalClassType::release();    
    return 0;
}