C++設計模式之單例模式詳解
單例模式：就是隻有一個實例。
singleton pattern單例模式：確保某一個類在程序運行中隻能生成一個實例，並提供一個訪問它的全局訪問點。這個類稱為單例類。如一個工程中，數據庫訪問對象隻有一個，電腦的鼠標隻能連接一個，操作系統隻能有一個窗口管理器等，這時可以考慮使用單例模式。
眾所周知，c++中，類對象被創建時，編譯系統為對象分配內存空間，並自動調用構造函數，由構造函數完成成員的初始化工作，也就是說使用構造函數來初始化對象。
1、那麼我們需要把構造函數設置為私有的 private，這樣可以禁止別人使用構造函數創建其他的實例。
2、又單例類要一直向系統提供這個實例，那麼，需要聲明它為靜態的實例成員，在需要的時候，才創建該實例。
3、且應該把這個靜態成員設置為 null，在一個public 的方法裡去判斷，隻有在靜態實例成員為 null，也就是沒有被初始化的時候，才去初始化它，且隻被初始化一次。
通常我們可以讓一個全局變量使得一個對象被訪問，但它不能阻止你實例化多個對象。如果采用全局或者靜態變量的方式，會影響封裝性，難以保證別的代碼不會對全局變量造成影響。
一個最好的辦法是，讓類自身負責保存它的唯一實例。這個類可以保證沒有其他實例可以被創建，並且它可以提供一個訪問該實例的方法，單例模式比全局對象好還包括，單例類可以繼承。
單例模式又分為兩種基本的情形：餓漢式和懶漢式
直接在靜態區初始化 instance，然後通過 get 方法返回，這樣這個類每次直接先生成一個對象，好像好久沒吃飯的餓漢子，急著吃飯一樣，急切的 new 對象，這叫做餓漢式單例類。或者是在 get 方法中才 new instance，然後返回這個對象，和懶漢字一樣，不主動做事，需要調用 get 方法的時候，才 new 對象，這就叫做懶漢式單例類。
如下是懶漢式單例類
//單例模式示例
class Singleton
{
public:
static Singleton * getInstance()
{
if (instance == NULL) {
instance = new Singleton();
}
return instance;
}
private:
//私有的構造函數，防止外人私自調用
Singleton()
{
cout << "實例化瞭" << count << "個對象！" << endl;
count++;
}
//聲明一個靜態實例，靜態函數隻能使用靜態的數據成員。整個類中靜態成員隻有一個實例，通常在實現源文件中被初始化。
static Singleton *instance;
//記錄實例化的對象
int count = 1;
};
Singleton * Singleton::instance = NULL;
int main(void)
{
Singleton::getInstance();
Singleton::getInstance();
Singleton::getInstance();
Singleton::getInstance();
return 0;
}
實例化瞭1個對象！
Program ended with exit code: 0
小結：
懶漢式單例模式是用時間換取控件，餓漢式單例模式，是用空間換取時間。
繼續分析，考慮多線程下的懶漢式單例模式
上述代碼在單線程的情況下，運行正常，但是遇到瞭多線程就出問題，假設有兩個線程同時運行瞭這個單例類，同時運行到瞭判斷 if 語句，並且當時，instance 實例確實沒有被初始化呢，那麼兩個線程都會去運行並創建實例，此時就不滿足單例類的要求瞭。那麼我們需要寫上線程同步的功能。
//考慮到多線程情形下的單例模式
class Singleton
{
public:
//get 方法
static Singleton * getInstance(){
//聯系互斥信號量機制，給代碼加鎖
lock();
//判斷 null
if (NULL == instance) {
//判斷類沒有生成對象，才實例化對象，否則不再實例化
instance = new Singleton();
}
//使用完畢，解鎖
unlock();
//返回一個實例化的對象
return instance;
}
private:
//聲明對象計數器
int count = 0;
//聲明一個靜態的實例
static Singleton *instance;
//私有構造函數
Singleton(){
count++;
cout << "實例化瞭" << count << "個對象！" << endl;
}
};
//初始化 instance
Singleton * Singleton::instance = NULL;
此時，還是有 ab 兩個線程來運行這個單例類，由於在同一時刻，隻有一個線程能拿到同步鎖（互斥信號量機制），a 拿到瞭同步鎖，b 隻能等待，如果 a發現實例還沒創建，a 就會創建一個實例，創建完畢，a 釋放同步鎖，然後 b 才能拿到同步鎖，繼續運行接下來的代碼，b 發現 a 線程運行的時候，已經生成瞭一個實例，b 線程就不會重復創建實例瞭，這樣就保證瞭我們在多線程環境中隻能得到一個實例。
繼續分析多線程下的懶漢式單例模式
代碼中，每次 get 方法中，得到 instance，都要判斷是否為空，且判斷是否為空之前，都要先加同步鎖，如果線程很多的時候，就要先等待加瞭同步鎖的線程運行完畢，才能繼續判斷餘下的線程，這樣就會造成大量線程的阻塞，且加鎖是個非常消耗時間的過程，應該盡量避免（除非很有必要的時候）。可行的辦法是，雙重判斷方法。
因為，隻是在實例還沒有創建的時候，需要加鎖判斷，保證每次隻有一個線程創建實例，而當實例已經創建之後，其實就不需要加鎖操作瞭。
雙重判斷的線程安全的懶漢式單例模式
class Singleton
{
public:
//get 方法
static Singleton * getInstance(){
//先判斷一次 null，隻有 null 的時候需要加鎖，其他的時候，其實不需要加鎖
if (NULL == instance) {
//聯系互斥信號量機制，給代碼加鎖
lock();
//然後再次判斷 null
if (NULL == instance) {
//判斷類沒有生成對象，才實例化對象，否則不再實例化
instance = new Singleton();
}
//使用完畢，解鎖
unlock();
}
//返回一個實例化的對象
return instance;
}
private:
//聲明對象計數器
int count = 0;
//聲明一個靜態的實例
static Singleton *instance;
//私有構造函數
Singleton(){
count++;
cout << "實例化瞭" << count << "個對象！" << endl;
}
};
//初始化 instance
Singleton * Singleton::instance = NULL;
這樣的雙重檢測機制，提高瞭單例模式在多線程下的效率，因為這樣的代碼，隻需要在第一次創建實例的時候，需要加鎖，其他的時候，線程無需排隊等待加鎖之後，再去判斷瞭，比較高效。
再看餓漢式的單例模式，之前看瞭懶漢式的單例類，是線程不安全的，通過加鎖（雙重鎖），實現線程安全
回憶餓漢式單例類：直接在靜態區初始化 instance，然後通過 get 方法返回，這樣這個類每次直接先生成一個對象，好像好久沒吃飯的餓漢子，急著吃飯一樣，急切的 new 對象，這叫做餓漢式單例類。
class Singleton
{
public:
//get 方法
static Singleton * getInstance(){
//返回一個實例化的對象
return instance;
}
private:
//聲明一個靜態的實例
static Singleton *instance;
//私有構造函數
Singleton(){
}
};
//每次先直接實例化instance，get 方法直接返回這個實例
Singleton * Singleton::instance = new Singleton();
註意：靜態初始化實例可以保證線程安全，因為靜態實例初始化在程序開始時進入主函數之前，就由主線程以單線程方式完成瞭初始化！餓漢式的單例類，也就是靜態初始化實例保證其線程安全性，故在性能需求較高時，應使用這種模式，避免頻繁的鎖爭奪。
繼續看單例模式
上面的單例模式沒有 destory() 方法，也就是說，貌似上面的單例類沒有主動析構這個唯一實例！然而這就導致瞭一個問題，在程序結束之後，該單例對象沒有delete，導致內存泄露！下面是一些大神的方法：一個妥善的方法是讓這個類自己知道在合適的時候把自己刪除，或者說把刪除自己的操作掛在操作系統中的某個合適的點上，使其在恰當的時候被自動執行。
我們知道，程序在結束的時候，系統會自動析構所有的全局變量。事實上，系統也會析構所有的類的靜態成員變量，就像這些靜態成員也是全局變量一樣。如果在類的析構行為中有必須的操作，比如關閉文件，釋放外部資源，那麼上面的代碼無法實現這個要求。我們需要一種方法，正常的刪除該實例。利用這些特征，我們可以在單例類中定義一個這樣的靜態成員變量，而它的唯一工作就是在析構函數中刪除單例類的實例。如下面的代碼中的Garbage類：
class Singleton
{
public:
//get 方法
static Singleton * getInstance(){
//判斷單例否
if (NULL == instance) {
instance = new Singleton();
}
//返回一個實例化的對象
return instance;
}
//c++ 嵌套的內部類，作用是刪除單例類對象，Garbage被定義為Singleton的內嵌類，以防該類被在其他地方濫用。
class Garbage
{
public:
~Garbage(){
if (Singleton::instance != NULL) {
cout << "單例類的唯一實例被析構瞭" << endl;
delete Singleton::instance;
}
}
};
private:
//單例類中聲明一個觸發垃圾回收類的靜態成員變量，它的唯一工作就是在析構函數中刪除單例類的實例，利用程序在結束時析構全局變量的特性，選擇最終的釋放時機；
static Garbage garbage;
//聲明一個靜態的實例
static Singleton *instance;
//單例類的私有構造函數
Singleton(){
cout << "調用瞭單例類的構造函數" << endl;
}
//單例類的私有析構函數
~Singleton(){
cout << "調用瞭單例類的析構函數" << endl;
}
};
//初始化內部的靜態變量，目睹是啟動刪除的析構函數，如果不初始化，就不會被析構
//內部類可以訪問外部類的私有成員，外部類不能訪問內部類的私有成員！
Singleton::Garbage Singleton::garbage;
//初始化instance為 null
Singleton * Singleton::instance = NULL;
int main(void)
{
Singleton *a = Singleton::getInstance();
Singleton *b = Singleton::getInstance();
Singleton *c = Singleton::getInstance();
if (a == b) {
cout << "a = b" << endl;
}
return 0;
}
調用瞭單例類的構造函數
a = b
單例類的唯一實例被析構瞭
調用瞭單例類的析構函數
Program ended with exit code: 0
類Garbage被定義為Singleton的內嵌類，以防該類在其他地方濫用，程序運行結束時，系統會調用Singleton的靜態成員garbage的析構函數，該析構函數會刪除單例的唯一實例，使用這種方法釋放單例對象有以下特征：
1、在單例類內部定義專有的嵌套類；
2、在單例類內定義私有的專門用於釋放的靜態成員；
3、利用程序在結束時析構全局變量的特性，選擇最終的釋放時機；
4、使用單例的代碼不需要任何操作，不必關心對象的釋放。
其實，繼續想單例類的實現，有的人會這樣做：
在程序結束時調一個專門的方法，這個方法裡判斷實例對象是否為 null，如果不為 null，就對返回的指針掉用delete操作。這樣做可以實現刪除單例的功能，但不僅很醜陋，而且容易出錯。因為這樣的附加代碼很容易被忘記，而且也很難保證在delete之後，沒有代碼再調用GetInstance函數。不推薦直接的刪除方法。
繼續查看單例模式：單例模式在實際開發過程中是很有用的
單例模式的特征總結：
1、一個類隻有一個實例
2、提供一個全局訪問點
3、禁止拷貝
逐個分析：
1、實現隻有一個實例，需要做的事情：將構造函數聲明為私有
2、提供一個全局訪問點，需要做的事情：類中創建靜態成員和靜態成員方法
3、禁止拷貝：把拷貝構造函數聲明為私有，並且不提供實現，將賦值運算符聲明為私有，防止對象的賦值
完整的單例類實現代碼如下：
class Singleton
{
public:
//get 方法
static Singleton * getInstance(){
if (NULL == instance) {
lock();
//判斷單例否
if (NULL == instance) {
instance = new Singleton();
}
unlock();
}
//返回一個實例化的對象
return instance;
}
//c++ 嵌套的內部類，作用是刪除單例類對象，Garbage被定義為Singleton的私有內嵌類，以防該類被在其他地方濫用。
class Garbage
{
public:
~Garbage(){
if (Singleton::instance != NULL) {
cout << "單例類的唯一實例被析構瞭" << endl;
delete Singleton::instance;
}
}
};
private:
//單例類中定義一個這樣的靜態成員變量，而它的唯一工作就是在析構函數中刪除單例類的實例，利用程序在結束時析構全局變量的特性，選擇最終的釋放時機；
static Garbage garbage;
//聲明一個靜態的實例
static Singleton *instance;
//單例類的私有構造函數
Singleton(){
cout << "調用瞭單例類的構造函數" << endl;
}
//單例類的私有析構函數
~Singleton(){
cout << "調用瞭單例類的析構函數" << endl;
}
//把拷貝構造函數聲明為私有，就可以禁止外人拷貝對象，也不用實現它，聲明私有即可
Singleton(const Singleton ©);
//把賦值運算符重載為私有的，防止對象之間的賦值操作
Singleton & operator=(const Singleton &other);
};
//初始化內部似有淚的靜態變量，目睹是啟動刪除的析構函數，如果不初始化，就不會被析構
//內部類可以訪問外部類的私有成員，外部類不能訪問內部類的私有成員！
Singleton::Garbage Singleton::garbage;
//初始化instance為 null
Singleton * Singleton::instance = NULL;
int main(void)
{
Singleton *a = Singleton::getInstance();
Singleton *b = Singleton::getInstance();
Singleton *c = Singleton::getInstance();
if (a == b) {
cout << "a = b" << endl;
}
return 0;
}
單例類de測試，兩個方法：
1、實例化多個對象，看調用瞭幾次構造函數，如果隻調用一次，說明隻創建一個實例
2、單步跟蹤，查看對象的地址，是否一樣，一樣則為一個對象
總結
本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！