文章目錄
- 單例模式
- 使用場景
- c++實現
- 靜態局部變量
- 餓漢式（線程安全）
- 懶漢式（線程安全）
- 懶漢式（線程安全）+ 智能指針
- 懶漢式(線程安全)+智能指針+call_once
- 懶漢式(線程安全)+智能指針+call_once+CRTP
單例模式
單例模式是指在內存只會創建且僅創建一次對象的設計模式，確保在程序運行期間只有唯一的實例。
使用場景
當對象需要被共享的時候又或者某類需要頻繁實例化.
- 設備管理器，系統中可能有多個設備，但是只有一個設備管理器，用于管理設備驅動;
- 數據池，用來緩存數據的數據結構，需要在一處寫，多處讀取或者多處寫，多處讀取;
- 回收站,在整個系統運行過程中，回收站一直維護著僅有的一個實例;
- 應用程序的日志應用，一般都何用單例模式實現，這一般是由于共享的日志文件一直處于打開狀態，因為只能有一個實例去操作，否則內容不好追加;
- 網站的計數器，一般也是采用單例模式實現，否則難以同步。
實際開發中，如果不是完美符合使用場景，不推薦使用。
如果實際開發經驗不夠，很容易看什么都是單例。
c++實現
單例模式的關鍵點：創建且僅創建一次對象
2個關鍵點：
- 如何只創建一次？
- 如何禁止拷貝和賦值？（保證只有一個）
靜態局部變量
對于1：這很容易想到靜態局部變量
當一個函數中定義一個局部靜態變量，那么這個局部靜態變量只會初始化一次，就是在這個函數第一次調用的時候，以后無論調用幾次這個函數，函數內的局部靜態變量都不再初始化。
對于2：可以將拷貝構造和賦值重載設置位私有成員。
綜上，我們可以得到第一個版本
class Singleton1
{
public:static Singleton1& getInstance(){static Singleton1 s_single;return s_single;}
private:Singleton1() = default;Singleton1(const Singleton1&) = delete;Singleton1& operator=(const Singleton1&) = delete;
};
上述版本的單例模式在C++11 以前存在多線程不安全的情況，多個線程同時執行這段代碼，編譯器可能會初始化多個靜態變量。
magic static, 它是C++11標準中提供的新特性
- 如果在初始化變量時控制同時進入聲明，則并發執行應等待初始化完成。
- 如果當變量在初始化的時候，并發同時進入聲明語句，并發線程將會阻塞等待初始化結束。
即c++規定各廠商優化編譯器，能保證線程安全。所以為了保證運行安全請確保使用C++11以上的標準。
但是有些編譯器它就是不遵循c++的規定，比如vistual studio
/Zc:threadSafeInit 是 Microsoft Visual Studio 編譯器中的一個編譯選項，作用是啟用或禁用線程安全的靜態局部變量初始化。這個選項對于 C++11 引入的“magic statics”（線程安全的靜態局部變量）機制尤為重要。
當啟用 /Zc:threadSafeInit（默認在 C++11 及更高標準中啟用）時，編譯器會確保靜態局部變量的初始化是線程安全的。這意味著如果多個線程首次訪問同一個靜態局部變量，編譯器會保證該變量只被初始化一次，并確保其他線程可以看到初始化后的正確值。
在項目- 屬性 - C/C++ -命令行里可以查看，我這里沒有，即默認開啟。
實際開發中一定要注意是否遵循規定。
如果遵循，推薦使用靜態局部變量的方式，又簡單又安全。
餓漢式（線程安全）
餓漢式：程序啟動即初始化
在C++11 推出以前，局部靜態變量的方式實現單例存在線程安全問題，所以部分人提出了一種方案，就是在主線程啟動后，其他線程沒有啟動前，由主線程先初始化單例資源，這樣其他線程獲取的資源就不涉及重復初始化的情況了。
//餓漢式初始化
class Singleton2
{
public:static Singleton2* getInstance(){if (s_single == nullptr){s_single = new Singleton2();}return s_single;}
private:Singleton2() = default;Singleton2(const Singleton2&) = delete;Singleton2& operator=(const Singleton2&) = delete;static Singleton2* s_single;
};
Singleton2* Singleton2::s_single = Singleton2::getInstance();
雖然從使用的角度規避多線程的安全問題，但是又引出了很多問題，如1. 啟動即初始化，可能導致程序啟動時間延長。2. 從規則上束縛了開發者
懶漢式（線程安全）
懶漢式：需要時即初始化
事例何時初始化應該由開發者決定。因此我們使用懶漢式初始化。但懶漢式初始化存在線程安全問題，即資源的重復初始化，因此，我們需要加鎖。
#include <mutex>
class Singleton3
{
public:static Singleton3* getInstance(){//這里不加鎖判斷，提高性能if (s_single != nullptr){return s_single;}s_mutex.lock();//1處if (s_single != nullptr) //2處{s_mutex.unlock();return s_single;}s_single = new Singleton3();//3處s_mutex.unlock();return s_single;}
private:Singleton3() = default;Singleton3(const Singleton3&) = delete;Singleton3& operator=(const Singleton3&) = delete;static Singleton3* s_single;static std::mutex s_mutex;
};
Singleton3* Singleton3::s_single = nullptr;
std::mutex Singleton3::s_mutex;
為什么2處要加一個判斷呢？
假如現在有線程A, B同時調用getInstance()
- 此時s_single == nullptr， A和B同時進入1處，假設A加上鎖，B等待
- A執行完3處的命令后，通過s_mutex.unlock()解鎖，此時B加上鎖。
- 如果沒有2處，B會再執行一遍3處，這會導致內存泄漏，而加上2處后，B會判斷s_single != nullptr, 解鎖返回
懶漢式（線程安全）+ 智能指針
但這還沒完，懶漢式相比餓漢式有一個最大的不同：不確定是哪個線程初始化的。那之后由誰析構呢？
其實不必操心，我們可以利用c++的RAIII，使用智能指針。
#include <mutex>
class Singleton3
{
public:static std::shared_ptr<Singleton3> getInstance(){if (s_single != nullptr){return s_single;}s_mutex.lock();if (s_single != nullptr){s_mutex.unlock();return s_single;}s_single = std::shared_ptr<Singleton3>(new Singleton3);s_mutex.unlock();return s_single;}
private:Singleton3() = default;Singleton3(const Singleton3&) = delete;Singleton3& operator=(const Singleton3&) = delete;static std::shared_ptr<Singleton3> s_single;static std::mutex s_mutex;
};
std::shared_ptr<Singleton3> Singleton3::s_single = nullptr;
std::mutex Singleton3::s_mutex;
有些人認為雖然智能指針能自動回收內存，如果有開發人員手動delete指針怎么辦？將析構函數設為私有，為智能指針添加刪除器。
#include <mutex>
class Singleton3
{
public:static std::shared_ptr<Singleton3> getInstance(){if (s_single != nullptr){return s_single;}s_mutex.lock();if (s_single != nullptr){s_mutex.unlock();return s_single;}s_single = std::shared_ptr<Singleton3>(new Singleton3, [](Singleton3* single) {delete single;});s_mutex.unlock();return s_single;}
private:Singleton3() = default;~Singleton3() = default; //析構私有Singleton3(const Singleton3&) = delete;Singleton3& operator=(const Singleton3&) = delete;static std::shared_ptr<Singleton3> s_single;static std::mutex s_mutex;
};
std::shared_ptr<Singleton3> Singleton3::s_single = nullptr;
std::mutex Singleton3::s_mutex;
上面的代碼仍然存在危險，主要原因在于new操作是由三部分組成的
-
分配內存
在第一個階段，new 操作會調用內存分配函數（默認是 operator new），在堆上為新對象分配足夠的空間。如果內存分配失敗，通常會拋出 std::bad_alloc 異常。 -
調用構造函數
分配到內存后，new 操作會在剛剛分配的內存上調用對象的構造函數，初始化該對象的各個成員。構造函數的參數可以在 new 語句中直接傳遞。 -
返回指針
構造函數執行完畢后，new 操作會返回一個指向新創建對象的指針。如果是 new[] 操作符（即分配數組），則返回指向數組起始元素的指針
這里的問題就再2和3的順序上，有些編譯器會優化，將2和3的順序顛倒。
static Singleton3* getInstance(){if (s_single != nullptr) //1處{return s_single;}s_mutex.lock();if (s_single != nullptr) {s_mutex.unlock();return s_single;}s_single = new Singleton3();//2處s_mutex.unlock();return s_single;}
如果2和3的順序顛倒，那么順序變為
1.分配內存
3.返回指針
2.調用構造
可能出現下面的情況：
線程A執行到2處的new的第3步，此時s_single已經不為空，但是指向的對象還未調用構造。
線程B剛好執行1處，此時s_single != nullptr, 直接返回s_single。外部將接受到一個還沒來的及調用構造函數的對象的指針。
為解決這個問題，C++11 推出了std::call_once函數保證多個線程只執行一次
懶漢式(線程安全)+智能指針+call_once
std::call_once 是 C++11 引入的一個函數，用于保證某段代碼在多線程環境中只被執行一次。這對單例模式、懶加載或只需執行一次的初始化操作非常有用。
std::call_once 與一個 std::once_flag 對象配合使用。std::once_flag 是一個標志，確保 std::call_once 所調用的函數只會執行一次，不論有多少個線程試圖同時調用它。
#include <mutex>
class Singleton
{
public:static std::shared_ptr<Singleton> getInstance(){static std::once_flag s_flag;std::call_once(s_flag, [&]() {s_single = std::shared_ptr<Singleton>(new Singleton, [](Singleton* single) {delete single;});});return s_single;}
private:Singleton() = default;~Singleton() = default; //析構私有Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;static std::shared_ptr<Singleton> s_single;
};
std::shared_ptr<Singleton> Singleton::s_single = nullptr;
懶漢式(線程安全)+智能指針+call_once+CRTP
為了讓單例類更通用，可以通過繼承實現多個單例類。
注：這里需要使用c++的CRTP（奇異遞歸模板模式），不知道是什么，自己查一下。
#include <mutex>
template<typename T>
class Singleton
{
public:static std::shared_ptr<T> getInstance(){static std::once_flag s_flag;std::call_once(s_flag, [&]() {s_instance = std::shared_ptr<T>(new T);});return s_instance;}
protected: Singleton() = default;Singleton(const Singleton<T>&) = delete;Singleton& operator=(const Singleton<T>&) = delete;static std::shared_ptr<T> s_instance;
};
template<typename T>
std::shared_ptr<T> Singleton<T>::s_instance = nullptr;class A :public Singleton<A> //CRTP
{friend class Singleton<A>;
public://...};
friend class Singleton<A>;的目的是允許 Singleton<A> 類訪問 A 的受保護構造函數。沒有這個 friend 聲明，Singleton<A> 將無法調用 A 的構造函數，從而無法在 getInstance 方法中正確地創建 A 的實例。
)
