詳解C++實現線程安全的單例模式

2020-01-26 13:30:35

字體：大中小

來源：轉載

供稿：網友

在某些應用環境下面，一個類只允許有一個實例，這就是著名的單例模式。單例模式分為懶漢模式，跟餓漢模式兩種。

首先給出餓漢模式的實現

正解：

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>

在實例化m_instance 變量時，直接調用類的構造函數。顧名思義，在還未使用變量時，已經對m_instance進行賦值，就像很饑餓的感覺。這種模式，在多線程環境下肯定是線程安全的，因為不存在多線程實例化的問題。

下面來看懶漢模式

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(){  if( m_instance == NULL)  {     m_instance = new T();  }  return m_instance;} template <class T>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;

上面的單例類使用了模板，對每一種類型的變量都能實例化出唯一的一個實例。

例如要實例化一個int類型

int *p = singleton<int>::GetInstance()

例如要實例化一個string類型

string *p = singleton<string>::GetInstance()

在上面的實現中，在實例化對象時，調用GetInstance()函數時都沒有傳遞參數，這是猶豫不同的對象其初始化時參數個數都不一樣。如果要支持不同類型的對象帶參數初始化，則需要重載GetInstance函數。然而在c++11中，已經支持了可變參數函數。這里給出一個簡單的例子

#ifndef _SINGLETON_H_#define _SINGLETON_H_ template <class T>class singleton{protected:  singleton(){};private:  singleton(const singleton&){};  singleton& operator=(const singleton&){};  static T* m_instance;public:  template <typename... Args>  static T* GetInstance(Args&&... args)  {    if(m_instance == NULL)      m_instance = new T(std::forward<Args>(args)...);    return m_instance;  }    static void DestroyInstance()  {    if(m_instance )      delete m_instance;    m_instance = NULL;  }};  template <class T>T* singleton<T>::m_instance = NULL; #endif

測試函數

#include <iostream>#include <string>#include "singleton.h" using namespace std;struct A{  A(int a ,int b):_a(a),_b(b)  {}  int _a;  int _b;}; int main(){  int *p1 = singleton<int>::GetInstance(5);  int *p2 = singleton<int>::GetInstance(10);  cout << *p1 << " " << *p2 <<endl;  string *p3 = singleton<string>::GetInstance("aa");  string *p4 = singleton<string>::GetInstance("bb");   cout << *p3 << " " << *p4 <<endl;   A *p5 = singleton<A>::GetInstance(1,2);   A *p6 = singleton<A>::GetInstance(4,5);   cout << p5->_a << " " << p6->_a<<endl;  return 0;}

運行結果如下