分類

懶漢式：實例對象在第一次被使用時才進行初始化。

餓漢式：實例在定義時就被初始化。

特點

1、構造函數和析構函數私有化，不允許外部創建實例對象。

2、拷貝構造函數和複製運算符重載被delete，不允許產生新的實例。

3、內部定義一個私有的靜態數據成員，該成員為本類的實例化對象。

4、提供公有靜態成員方法獲取該靜態對象。

懶漢式

單線程懶漢式實現

 1 class Singleton
 2 {
 3 public:
 4     static Singleton* Ins()
 5     {
 6         if (_ins == nullptr)
 7             _ins = new Singleton();
 8         return _ins;
 9     }
10 
11 protected:
12     Singleton() {}
13     ~Singleton() {}
14     Singleton(const Singleton&) = delete;
15     Singleton& operator=(const Singleton&) = delete;
16 
17 private:
18     static Singleton* _ins;
19 };

缺陷：

• 非線程安全：假設目前有2個線程同時訪問Singleton::Ins方法，線程A在if條件判斷為真後，失去時間片，此時_ins還未初始化。線程B訪問Singleton::Ins，由於在A線程中還未初始化_ins，導致B線程創建對象並將_ins初始化完成。此時，時間片再次回到A線程，還原現場，上一個時間片中已經判斷過if條件，_ins將調用new創建新對象實例，導致對象被創建兩次，記憶體泄漏。
• 記憶體泄漏：在類中，我們只負責new了一個對象，並未對其delete,導致記憶體泄漏。

下麵將用雙重鎖+智能指針解決上面缺陷。

雙重鎖+智能指針實現

 1 class Singleton
 2 {
 3 public:
 4     ~Singleton() { std::cout << "destructor" << std::endl; }    //必須聲明為public
 5 
 6     static std::shared_ptr<Singleton> Ins()
 7     {
 8         if (_ins == nullptr)
 9         {
10             std::lock_guard<std::mutex> lock(_mt);
11             if (_ins == nullptr)
12             {
13                 _ins = std::shared_ptr<Singleton>(new Singleton());
14             }
15         }
16         return _ins;
17     }
18 
19     Singleton(const Singleton&) = delete;
20     Singleton& operator=(const Singleton&) = delete;
21 
22 protected:
23     Singleton() { std::cout << "constructor" << std::endl; }
24 
25 private:
26     static std::shared_ptr<Singleton> _ins;
27     static std::mutex _mt;
28 };

缺點：

• 雙重鎖在特定環境下依舊是非線程安全的。
• 強制用戶使用智能指針，並且要求將析構函數定義為piblic，可能在實際使用中忽略了該問題導致程式編譯出錯。

局部靜態變數法（推薦）

 1 class Singleton
 2 {
 3 public:
 4     static Singleton& Ins()
 5     {
 6         static Singleton _ins;
 7         return _ins;
 8     }
 9 
10     Singleton(const Singleton&) = delete;
11     Singleton& operator=(const Singleton&) = delete;
12 
13 protected:
14     Singleton() { std::cout << "constructor" << std::endl; }
15     ~Singleton() { std::cout << "destructor" << std::endl; }
16 };

C++11標準中定義了一個Magic Static特性：如果變數當前處於初始化狀態，當發生併發訪問時，併發線程將會阻塞，等待初始化結束。

std::call_once + 內部類方法

 1 class Singleton
 2 {
 3 public:
 4     static Singleton* Ins()
 5     {
 6         std::call_once(_flag, []() {
 7             _ins = new Singleton;
 8         });
 9         return _ins;
10     }
11 
12     Singleton(const Singleton&) = delete;
13     Singleton& operator=(const Singleton&) = delete;
14 
15 protected:
16     Singleton() { std::cout << "constructor" << std::endl; }
17     ~Singleton() { std::cout << "destructor" << std::endl; }    //必須聲明為私有，否則返回指針將可析構
18 
19 private:
20     struct Deleter
21     {
22         ~Deleter() {
23             delete _ins;
24             _ins = nullptr;
25         }
26     };
27     static Deleter _deleter;
28     static Singleton* _ins;
29     static std::once_flag _flag;
30 };
31 
32 Singleton::Deleter Singleton::_deleter;
33 Singleton* Singleton::_ins = nullptr;
34 std::once_flag Singleton::_flag;

缺點：不美觀，在類內部定義內部類，頭文件臃腫，適用於.h和.cpp分離的情況下使用。

餓漢式

 1 class Singleton
 2 {
 3 public:
 4     static Singleton& Ins()
 5     {
 6         return _ins;
 7     }
 8 
 9     Singleton(const Singleton&) = delete;
10     Singleton& operator=(const Singleton&) = delete;
11 
12 protected:
13     Singleton() { std::cout << "constructor" << std::endl; }
14     ~Singleton() { std::cout << "destructor" << std::endl; }
15 
16 private:
17     static Singleton _ins;
18 };
19 
20 Singleton Singleton::_ins;

模板單例

主要解決系統中存在多個模塊需要使用單例模式，通過模板+繼承解決代碼冗餘。

 1 template<typename T>
 2 class Singleton
 3 {
 4 public:
 5     static T& Ins()
 6     {
 7         static T _ins;
 8         return _ins;
 9     }
10 
11 protected:
12     Singleton() { std::cout << "constructor" << std::endl; }
13     ~Singleton() { std::cout << "destructor" << std::endl; }
14     Singleton(const Singleton&) = delete;
15     Singleton& operator=(const Singleton&) = delete;
16 };
17 
18 class AppInstance : public Singleton<AppInstance>
19 {
20     friend Singleton<AppInstance>;        //聲明友元
21     AppInstance() {}    //必須私有化
22     ~AppInstance() {}
23 public:
24     void func() { std::cout << "func"<< std::endl; }
25 };

總結

除非頻繁訪問或者頻繁創建和銷毀，儘量不要使用單例模式，可以用組合的方式代替。

在使用單例模式，需要確保線程安全、記憶體安全。設計時，儘量做到好用、簡單。