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

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

首先給出餓漢模式的實現

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進行賦值，就像很飢餓的感受。這種模式，在多線程環境下確定是線程安全的，由於不存在多線程實例化的問題。 

下面來看懶漢模式

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;
}

運行結果以下