問題描述
單例模式
何為單例模式，在GOF的《設計模式：可複用物件導向軟體的基礎》中是這樣說的：保證一個類只有一個例項，並提供一個訪問它的全域性訪問點。首先，需要保證一個類只有一個例項；在類中，要構造一個例項，就必須呼叫類的建構函式，如此，為了防止在外部呼叫類的建構函式而構造例項，需要將建構函式的訪問許可權標記為protected或private；最後，需要提供要給全域性訪問點，就需要在類中定義一個static函式，返回在類內部唯一構造的例項。意思很明白，使用UML類圖表示如下。
UML類圖
程式碼實現
單例模式，單從UML類圖上來說，就一個類，沒有錯綜複雜的關係。但是，在實際專案中，使用程式碼實現時，還是需要考慮很多方面的。
實現一：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
/* ** FileName : SingletonPatternDemo1 ** Author : Jelly Young ** Date : 2013/11/20 ** Description : More information, please go to http://www.jellythink.com */ #include <iostream> using namespace std; class Singleton { public: static Singleton *GetInstance() { if (m_Instance == NULL ) { m_Instance = new Singleton (); } return m_Instance; } static void DestoryInstance() { if (m_Instance != NULL ) { delete m_Instance; m_Instance = NULL ; } } // This is just a operation example int GetTest() { return m_Test; } private: Singleton(){ m_Test = 10; } static Singleton *m_Instance; int m_Test; }; Singleton *Singleton ::m_Instance = NULL; int main(int argc , char *argv []) { Singleton *singletonObj = Singleton ::GetInstance(); cout<<singletonObj->GetTest()<<endl; Singleton ::DestoryInstance(); return 0; } |
這是最簡單，也是最普遍的實現方式，也是現在網上各個部落格中記述的實現方式，但是，這種實現方式，有很多問題，比如：沒有考慮到多執行緒的問題，在多執行緒的情況下，就可能建立多個Singleton例項，以下版本是改善的版本。
實現二：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
/* ** FileName : SingletonPatternDemo2 ** Author : Jelly Young ** Date : 2013/11/20 ** Description : More information, please go to http://www.jellythink.com */ #include <iostream> using namespace std; class Singleton { public: static Singleton *GetInstance() { if (m_Instance == NULL ) { Lock(); // C++沒有直接的Lock操作，請使用其它庫的Lock，比如Boost，此處僅為了說明 if (m_Instance == NULL ) { m_Instance = new Singleton (); } UnLock(); // C++沒有直接的Lock操作，請使用其它庫的Lock，比如Boost，此處僅為了說明 } return m_Instance; } static void DestoryInstance() { if (m_Instance != NULL ) { delete m_Instance; m_Instance = NULL ; } } int GetTest() { return m_Test; } private: Singleton(){ m_Test = 0; } static Singleton *m_Instance; int m_Test; }; Singleton *Singleton ::m_Instance = NULL; int main(int argc , char *argv []) { Singleton *singletonObj = Singleton ::GetInstance(); cout<<singletonObj->GetTest()<<endl; Singleton ::DestoryInstance(); return 0; } |
此處進行了兩次m_Instance == NULL的判斷，是借鑑了Java的單例模式實現時，使用的所謂的“雙檢鎖”機制。因為進行一次加鎖和解鎖是需要付出對應的代價的，而進行兩次判斷，就可以避免多次加鎖與解鎖操作，同時也保證了執行緒安全。但是，這種實現方法在平時的專案開發中用的很好，也沒有什麼問題？但是，如果進行大資料的操作，加鎖操作將成為一個效能的瓶頸；為此，一種新的單例模式的實現也就出現了。
實現三：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
/* ** FileName : SingletonPatternDemo3 ** Author : Jelly Young ** Date : 2013/11/20 ** Description : More information, please go to http://www.jellythink.com */ #include <iostream> using namespace std; class Singleton { public: static Singleton *GetInstance() { return const_cast <Singleton *>(m_Instance); } static void DestoryInstance() { if (m_Instance != NULL ) { delete m_Instance; m_Instance = NULL ; } } int GetTest() { return m_Test; } private: Singleton(){ m_Test = 10; } static const Singleton *m_Instance; int m_Test; }; const Singleton *Singleton ::m_Instance = new Singleton(); int main(int argc , char *argv []) { Singleton *singletonObj = Singleton ::GetInstance(); cout<<singletonObj->GetTest()<<endl; Singleton ::DestoryInstance(); } |
因為靜態初始化在程式開始時，也就是進入主函式之前，由主執行緒以單執行緒方式完成了初始化，所以靜態初始化例項保證了執行緒安全性。在效能要求比較高時，就可以使用這種方式，從而避免頻繁的加鎖和解鎖造成的資源浪費。由於上述三種實現，都要考慮到例項的銷燬，關於例項的銷燬，待會在分析。由此，就出現了第四種實現方式：
實現四：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
/* ** FileName : SingletonPatternDemo4 ** Author : Jelly Young ** Date : 2013/11/20 ** Description : More information, please go to http://www.jellythink.com */ #include <iostream> using namespace std; class Singleton { public: static Singleton *GetInstance() { static Singleton m_Instance; return &m_Instance; } int GetTest() { return m_Test++; } private: Singleton(){ m_Test = 10; }; int m_Test; }; int main(int argc , char *argv []) { Singleton *singletonObj = Singleton ::GetInstance(); cout<<singletonObj->GetTest()<<endl; singletonObj = Singleton ::GetInstance(); cout<<singletonObj->GetTest()<<endl; } |
以上就是四種主流的單例模式的實現方式，如果大家還有什麼好的實現方式，希望大家能推薦給我。謝謝了。
例項銷燬
在上述的四種方法中，除了第四種沒有使用new操作符例項化物件以外，其餘三種都使用了；我們一般的程式設計觀念是，new操作是需要和delete操作進行匹配的；是的，這種觀念是正確的。在上述的實現中，是新增了一個DestoryInstance的static函式，這也是最簡單，最普通的處理方法了；但是，很多時候，我們是很容易忘記呼叫DestoryInstance函式，就像你忘記了呼叫delete操作一樣。由於怕忘記delete操作，所以就有了智慧指標；那麼，在單例模型中，沒有“智慧單例”，該怎麼辦？怎麼辦？
那我先從實際的專案中說起吧，在實際專案中，特別是客戶端開發，其實是不在乎這個例項的銷燬的。因為，全域性就這麼一個變數，全域性都要用，它的生命週期伴隨著軟體的生命週期，軟體結束了，它也就自然而然的結束了，因為一個程式關閉之後，它會釋放它佔用的記憶體資源的，所以，也就沒有所謂的記憶體洩漏了。但是，有以下情況，是必須需要進行例項銷燬的：
- 在類中，有一些檔案鎖了，檔案控制程式碼，資料庫連線等等，這些隨著程式的關閉而不會立即關閉的資源，必須要在程式關閉前，進行手動釋放；
- 具有強迫症的程式設計師。
以上，就是我總結的兩點。
雖然，在程式碼實現部分的第四種方法能滿足第二個條件，加上解構函式能滿足第一個條件。好了，接下來，就介紹另一種方法，這種方法也是我從網上學習而來的，程式碼實現如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
/* ** FileName : SingletonPatternDemo5 ** Author : Jelly Young ** Date : 2013/11/20 ** Description : More information, please go to http://www.jellythink.com */ #include <iostream> using namespace std; class Singleton { public: static Singleton *GetInstance() { return m_Instance; } int GetTest() { return m_Test; } private: Singleton(){ m_Test = 10; } static Singleton *m_Instance; int m_Test; // This is important class GC { public : ~GC() { // We can destory all the resouce here, eg:db connector, file handle and so on if (m_Instance != NULL ) { cout<< "Here is the test" <<endl; delete m_Instance; m_Instance = NULL ; } } }; static GC gc; }; Singleton *Singleton ::m_Instance = new Singleton(); Singleton ::GC Singleton ::gc; int main(int argc , char *argv []) { Singleton *singletonObj = Singleton ::GetInstance(); cout<<singletonObj->GetTest()<<endl; return 0; } |
在程式執行結束時，系統會呼叫Singleton的靜態成員GC的解構函式，該解構函式會進行資源的釋放，而這種資源的釋放方式是在程式設計師“不知道”的情況下進行的，而程式設計師不用特別的去關心，使用單例模式的程式碼時，不必關心資源的釋放。那麼這種實現方式的原理是什麼呢？我剖析問題時，喜歡剖析到問題的根上去，絕不糊塗的停留在表面。由於程式在結束的時候，系統會自動析構所有的全域性變數，實際上，系統也會析構所有類的靜態成員變數，就像這些靜態變數是全域性變數一樣。我們知道，靜態變數和全域性變數在記憶體中，都是儲存在靜態儲存區的，所以在析構時，是同等對待的。
由於此處使用了一個內部GC類，而該類的作用就是用來釋放資源，而這種使用技巧在C++中是廣泛存在的，在後面的部落格中，我會總結這一技巧，參見《C++中的RAII機制》。
模式擴充套件
在實際專案中，一個模式不會像我們這裡的程式碼那樣簡單，只有在熟練了各種設計模式的特點，才能更好的在實際專案中進行運用。單例模式和工廠模式在實際專案中經常見到，兩種模式的組合，在專案中也是很常見的。所以，有必要總結一下兩種模式的結合使用。
一種產品，在一個工廠中進行生產，這是一個工廠模式的描述；而只需要一個工廠，就可以生產一種產品，這是一個單例模式的描述。所以，在實際中，一種產品，我們只需要一個工廠，此時，就需要工廠模式和單例模式的結合設計。由於單例模式提供對外一個全域性的訪問點，所以，我們就需要使用簡單工廠模式中那樣的方法，定義一個標識，用來標識要建立的是哪一個單件。由於模擬程式碼較多，在文章最後，提供下載連結。
總結
為了寫這篇文章，自己調查了很多方面的資料，由於網上的資料在各方面都有很多的瑕疵，質量參次不齊，對我也造成了一定的誤導。而這篇文章，有我自己的理解，如有錯誤，請大家指正。
由於該文對設計模式的總結，我認為比網上80%的都全面，希望對大家有用。在實際的開發中，並不會用到單例模式的這麼多種，每一種設計模式，都應該在最適合的場合下使用，在日後的專案中，應做到有地放矢，而不能為了使用設計模式而使用設計模式。