单例模式(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;
}