标签：方法 ini null public ec2 turn 安全 lock closed
在某些应用环境下面，一个类只允许有一个实例，这就是著名的单例模式。单例模式分为懒汉模式，跟饿汉模式两种。 首先给出饿汉模式的实现
template <class T> class singleton { protected: singleton(){}; private: singleton(const singleton&){};//禁止拷贝 singleton& operator=(const singleton&){};//禁止赋值 static T* m_instance; public: static T* GetInstance(); }; template <class T> T* singleton<T>::GetInstance() { return m_instance; } template <class T> T* singleton<T>::m_instance = new T();
在实例化m_instance 变量时，直接调用类的构造函数。顾名思义，在还未使用变量时，已经对m_instance进行赋值，就像很饥饿的感觉。这种模式，在多线程环境下肯定是线程安全的，因为不存在多线程实例化的问题。
下面来看懒汉模式
1 template <class T> 2 class singleton 3 { 4 protected: 5 singleton(){}; 6 private: 7 singleton(const singleton&){}; 8 singleton& operator=(const singleton&){}; 9 static T* m_instance; 10 public: 11 static T* GetInstance(); 12 }; 13 14 15 template <class T> 16 T* singleton<T>::GetInstance() 17 { 18 if( m_instance == NULL) 19 { 20 m_instance = new T(); 21 } 22 return m_instance; 23 } 24 25 template <class T> 26 T* singleton<T>::m_instance = NULL;
懒汉模式下，在定义m_instance变量时先等于NULL，在调用GetInstance()方法时，在判断是否要赋值。这种模式，并非是线程安全的，因为多个线程同时调用GetInstance()方法，就可能导致有产生多个实例。要实现线程安全，就必须加锁。
下面给出改进之后的代码
template <class T> class singleton { protected: singleton(){}; private: singleton(const singleton&){}; singleton& operator=(const singleton&){}; static T* m_instance; static pthread_mutex_t mutex; public: static T* GetInstance(); }; template <class T> T* singleton<T>::GetInstance() { pthread_mutex_lock(&mutex); if( m_instance == NULL) { m_instance = new T(); } pthread_mutex_unlock(&mutex); return m_instance; } template <class T> pthread_mutex_t singleton<T>::mutex = PTHREAD_MUTEX_INITIALIZER; template <class T> T* singleton<T>::m_instance = NULL;
这一切看起来都很完美，但是程序猿是一种天生就不知道满足的动物。他们发现GetInstance()方法，每次进来都要加锁，会影响效率。然而这并不是必须的，于是又对GetInstance()方法进行改进
template <class T> T* singleton<T>::GetInstance() { if( m_instance == NULL) { pthread_mutex_lock(&mutex); if( m_instance == NULL) { m_instance = new T(); } pthread_mutex_unlock(&mutex); } return m_instance; }
这也就是所谓的“双检锁”机制。但是有人质疑这种实现还是有问题，在执行 m_instance = new T()时，可能 类T还没有初始化完成，m_instance 就已经有值了。这样会导致另外一个调用GetInstance()方法的线程，获取到还未初始化完成的m_instance 指针，如果去使用它，会有意料不到的后果。其实，解决方法也很简单，用一个局部变量过渡下即可：
template <class T> T* singleton<T>::GetInstance() { if( m_instance == NULL) { pthread_mutex_lock(&mutex); if( m_instance == NULL) { T* ptmp = new T(); m_instance = ptmp; } pthread_mutex_unlock(&mutex); } return m_instance; }
到这里在懒汉模式下，也就可以保证线程安全了。
然而，在linux下面还有另一种实现。linux提供了一个叫pthread_once()的函数，它保证在一个进程中，某个函数只被执行一次。下面是使用pthread_once实现的线程安全的懒汉单例模式
template <class T> class singleton { protected: singleton(){}; private: singleton(const singleton&){}; singleton& operator=(const singleton&){}; static T* m_instance; static pthread_once_t m_once; public: static void Init(); static T* GetInstance(); }; template <class T> void singleton<T>::Init() { m_instance = new T(); } template <class T> T* singleton<T>::GetInstance() { pthread_once(&m_once,Init); return m_instance; } template <class T> pthread_once_t singleton<T>::m_once = PTHREAD_ONCE_INIT; template <class T> T* singleton<T>::m_instance = NULL;
注意：文中的单例模式，构造函数全部是protected类型，第一是防止直接定义singleton类的变量，第二是为了singleton类可以被继承。一个项目中，可能有多个类型要实现成单例，这样只需要继承下singleton类即可。给一个简单的例子
class test:public singleton<test> { public: test(){}; ~test(){}; }; test *p = test::GetInstance();
转自http://www.cnblogs.com/myd620/p/6133420.html
标签：方法 ini null public ec2 turn 安全 lock closed
原文地址：http://www.cnblogs.com/taukeWang/p/6148692.html
