單例模式是最簡單的設計模式之一。在實際工程中，如果一個類的對象重復持有資源的成本很高，且對外接口是線程安全的，我們往往傾向于將其以單例模式管理。

此篇我們在 C++ 中實現正確的單例模式。

選型

在 C++ 中，單例模式有兩種方案可選。

• 一是實現一個沒有可用的公開構造函數的基類，并提供 GetInstance 之類的靜態(tài)接口，以便訪問子類唯一的對象。由于子類構造必須調用基類構造，但基類無公開構造函數可用，這使得子類對象只能由基類及基類的友元來構造，從而在機制上保證單例。
• 二是實現一個類模板，其模板參數是希望由單例管理的類的名字，并提供 GetInstance 之類的靜態(tài)接口。這種做法的好處是希望被單例管理的類，可以自由編寫，而無需繼承基類；并且在需要的時候，可以隨時脫去單例外衣。

此篇選擇實現一個單例類模板，其形如：

template <typename T>
struct Singleton {
 static T* get();
 T* operator->() const {
 return get();
 }
};

這里重載成員訪問運算符，是為了可以實現這樣的簡寫 Singleton<T>()->func()。

顯然，單例的實現核心在于靜態(tài)成員函數 T* get()。

一個典型的錯誤實現

一個典型的錯誤實現，是使用所謂的雙重檢查（double check）。

#include <mutex>

template <typename T>
struct Singleton {
 static T* get() {
 static T* p{nullptr};
 if (nullptr == p) {
  std::lock_guard<std::mutex> lock{mtx};
  if (nullptr == p) {
  p = new T;
  }
 }
 return p;
 }
 T* operator->() const {
 return get();
 }

 private:
 static std::mutex mtx;
};

template <typename T>
std::mutex Singleton<T>::mtx;

外層的檢查，是為了避免鎖住過大的區(qū)域，從而導致鎖的競爭特別頻繁；內層的檢查，是為了確保只在別的線程沒有提前搶占鎖完成初始化工作而設計的。這種做法在 Java 下是正確的，但是在 C++ 下則沒有保證。

另外，值得一提的是，這里 p 的初始化的線程安全性，是由 C++ 標準保證的?！?C++11 之后，標準保證函數靜態(tài)成員的初始化是線程安全的；對其讀寫則不保證線程安全。

使用標準庫提供的設施

在單例的實現中，我們實際上是希望實現「執(zhí)行且只執(zhí)行一次」的語義。C++11 之后，標準庫實際已經提供了這樣的設施。其名為 std::once_flag 和 std::call_once。它們內部利用互斥量和條件變量組合，實現這樣的語義。值得一提的是，如果執(zhí)行過程中拋出異常，標準庫的設施不認為這是一次「成功的執(zhí)行」。于是其他線程可以繼續(xù)搶占鎖來執(zhí)行函數。

我們利用標準庫設施來實現這個類模板。

#include <mutex>

template <typename T>
struct Singleton {
 static T* get() {
 static T* p{nullptr};
 std::call_once(flag, [&]() -> void {
  p = new T;
 });
 return p;
 }
 T* operator->() const {
 return get();
 }

 private:
 static std::once_flag flag;
};

template <typename T>
std::once_flag Singleton<T>::flag;

于是你可以寫出類似這樣的代碼：

#include <mutex>
#include <iostream>
#include <future>
#include <vector>

#include "singleton.h"

struct Foo {
 void address() const {
 std::lock_guard<std::mutex> lock{mtx};
 std::cout << static_cast<void*>(const_cast<Foo*>(this)) << '\n';
 }
 mutable std::mutex mtx;
};

int main() {
 Singleton<Foo>()->address();
 std::vector<std::future<void>> futs;
 for (size_t i = 0; i != 10; ++i) {
 futs.emplace_back(std::async(&Foo::address, Singleton<Foo>::get()));
 }
 for (auto& fut : futs) {
 fut.get();
 }
 return 0;
}

得到的輸出類似這樣：

$ ./a.out
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10
0x7fbc6f405a10

Bonus：需要注意的是，所有的 std::once_flag 內部共享了同一對互斥量和條件變量。因此當存在很多 std::call_once 的時候，性能會有所下降。這一點可能需要注意一下。不過，如果存在很多 std::call_once，大概也說明程序設計不合理吧……

Bonus：注意我們這里沒有釋放 p 指向的對象。這是因為 C++ 程序對靜態(tài)變量的析構順序是不確定的。如果靜態(tài)變量之間有相互依賴，析構被依賴的對象可能會導致段錯誤。因此干脆就不釋放了，這是所謂的 LeakySingleton。當然，如果你的工程當中有實現一個通用的 ExitManager，是有可能正確析構的。但考慮到還可能大量使用第三方庫，而第三方庫不可能使用你實現的 ExitManager，于是管理所有靜態(tài)變量的析構又變得不可能，于是干脆就不管它了。

如此如此，這般這般

如果你仔細讀了這篇文章，你可能會忽然意識到剛才看到了這句話：「在 C++11 之后，標準保證函數靜態(tài)成員的初始化是線程安全的；對其讀寫則不保證線程安全。」

既然如此，我們?yōu)樯哆€要費勁使用 std::once_flag 和 std::call_once 呢？直接利用 static hack 出一個單例類模板不就好了嗎？

template <typename T>
struct Singleton {
 static T* get() {
 static T ins;
 return &ins;
 }
 T* operator->() const {
 return get();
 }
};

以上就是如何在 C++ 中實現一個單例類模板的詳細內容，更多關于c++ 單例類模板的資料請關注腳本之家其它相關文章！

最新評論