C++單例模式完整教學指南

📚 目錄

1. [單例模式基礎概念]
2. [經典單例實現及問題]
3. [現代C++推薦實現]
4. [高級話題：雙重檢查鎖]
5. [實戰應用與最佳實踐]
6. [總結與選擇指南]

---

1. 單例模式基礎概念

1.1 什么是單例模式？

單例模式（Singleton Pattern）是一種創建型設計模式，確保一個類只有一個實例，并提供全局訪問點。

1.2 應用場景

• 日志系統：全局統一的日志記錄器
• 配置管理：程序配置信息的統一管理
• 數據庫連接池：管理數據庫連接資源
• 線程池：管理線程資源
• 緩存系統：全局數據緩存

1.3 單例模式的核心要求

• ? 只能有一個實例
• ? 提供全局訪問點
• ? 禁止拷貝構造
• ? 禁止賦值操作
• ? 線程安全（多線程環境）

---

2. 經典單例實現及問題

2.1 樸素實現（? 有問題）

class Singleton {
private:static Singleton* instance;Singleton() = default;public:static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();  // 線程不安全！}return instance;}
};Singleton* Singleton::instance = nullptr;

問題分析：

• ? 線程不安全：多線程可能創建多個實例
• ? 內存泄漏：new出來的對象永遠不會被delete
• ? 沒有禁止拷貝和賦值

2.2 加鎖版本（? 安全但性能差）

class Singleton {
private:static Singleton* instance;static std::mutex mtx;Singleton() = default;public:Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;static Singleton* getInstance() {std::lock_guard<std::mutex> lock(mtx);  // 每次都加鎖，性能差if (instance == nullptr) {instance = new Singleton();}return instance;}
};Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

改進點：

• ? 線程安全
• ? 禁止拷貝和賦值
• ? 性能問題：每次調用都要加鎖
• ? 仍有內存泄漏

---

3. 現代C++推薦實現

3.1 Meyers單例（? 最推薦）

class Singleton {
private:Singleton() = default;~Singleton() = default;public:// 禁止拷貝和賦值Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;static Singleton& getInstance() {static Singleton instance;  // C++11起線程安全return instance;}// 示例方法void doSomething() {std::cout << "Singleton working..." << std::endl;}
};

優勢分析：

• ? 線程安全：C++11保證局部靜態變量初始化的線程安全性
• ? 性能優秀：初始化后調用無需加鎖
• ? 自動析構：程序結束時自動清理
• ? 代碼簡潔：無需手動管理內存和鎖

3.2 通用單例模板（? 可復用）

template <typename T>
class Singleton {
public:// 禁止拷貝和賦值Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;static T& getInstance() {static T instance;return instance;}protected:Singleton() = default;~Singleton() = default;
};// 使用示例
class Logger : public Singleton<Logger> {friend class Singleton<Logger>;  // 允許Singleton訪問私有構造函數private:Logger() { std::cout << "Logger initialized" << std::endl; }public:void log(const std::string& message) {std::cout << "[LOG] " << message << std::endl;}
};// 使用方法
int main() {Logger::getInstance().log("Hello Singleton!");return 0;
}

---

4. 高級話題：雙重檢查鎖

4.1 什么是雙重檢查鎖（DCLP）？

雙重檢查鎖定（Double-Checked Locking Pattern）是一種優化技術，減少鎖的使用頻率：

if (!instance) {           // 第一次檢查（無鎖）std::lock_guard<std::mutex> lock(mtx);if (!instance) {       // 第二次檢查（加鎖后）instance = new Singleton();}
}

4.2 傳統DCLP的問題

class UnsafeSingleton {
private:static std::shared_ptr<UnsafeSingleton> instance;static std::mutex mtx;public:static std::shared_ptr<UnsafeSingleton> getInstance() {if (!instance) {  // 問題：可能讀到"半成品"對象std::lock_guard<std::mutex> lock(mtx);if (!instance) {instance = std::make_shared<UnsafeSingleton>();  // 非原子操作}}return instance;}
};

問題根源： std::make_shared的執行過程不是原子的：

1. 分配內存
2. 調用構造函數
3. 設置指針值

其他線程可能在步驟2和3之間讀到未完全構造的對象！

4.3 安全的DCLP實現

template <typename T>
class SafeDCLPSingleton {
private:static std::atomic<std::shared_ptr<T>> instance;static std::mutex mtx;protected:SafeDCLPSingleton() = default;~SafeDCLPSingleton() = default;public:SafeDCLPSingleton(const SafeDCLPSingleton&) = delete;SafeDCLPSingleton& operator=(const SafeDCLPSingleton&) = delete;static std::shared_ptr<T> getInstance() {// 原子讀取auto temp = instance.load(std::memory_order_acquire);if (!temp) {std::lock_guard<std::mutex> lock(mtx);temp = instance.load(std::memory_order_relaxed);if (!temp) {temp = std::make_shared<T>();// 原子寫入instance.store(temp, std::memory_order_release);}}return temp;}
};// 靜態成員定義
template <typename T>
std::atomic<std::shared_ptr<T>> SafeDCLPSingleton<T>::instance{nullptr};template <typename T>
std::mutex SafeDCLPSingleton<T>::mtx;

---

5. 實戰應用與最佳實踐

5.1 日志系統實現

class Logger : public Singleton<Logger> {friend class Singleton<Logger>;private:std::mutex log_mtx;std::ofstream log_file;Logger() {log_file.open("application.log", std::ios::app);}~Logger() {if (log_file.is_open()) {log_file.close();}}public:enum LogLevel { INFO, WARNING, ERROR };void log(LogLevel level, const std::string& message) {std::lock_guard<std::mutex> lock(log_mtx);auto now = std::chrono::system_clock::now();auto time_t = std::chrono::system_clock::to_time_t(now);log_file << "[" << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S") << "] ";switch (level) {case INFO: log_file << "[INFO] "; break;case WARNING: log_file << "[WARN] "; break;case ERROR: log_file << "[ERROR] "; break;}log_file << message << std::endl;log_file.flush();}
};// 使用示例
int main() {Logger::getInstance().log(Logger::INFO, "Application started");Logger::getInstance().log(Logger::ERROR, "Something went wrong");return 0;
}

5.2 配置管理器

class ConfigManager : public Singleton<ConfigManager> {friend class Singleton<ConfigManager>;private:std::unordered_map<std::string, std::string> config_data;mutable std::shared_mutex config_mtx;ConfigManager() {loadFromFile("config.ini");}void loadFromFile(const std::string& filename) {// 簡化的配置文件加載邏輯config_data["database_url"] = "localhost:3306";config_data["max_connections"] = "100";config_data["debug_mode"] = "true";}public:std::string getValue(const std::string& key, const std::string& default_value = "") const {std::shared_lock<std::shared_mutex> lock(config_mtx);auto it = config_data.find(key);return (it != config_data.end()) ? it->second : default_value;}void setValue(const std::string& key, const std::string& value) {std::unique_lock<std::shared_mutex> lock(config_mtx);config_data[key] = value;}int getIntValue(const std::string& key, int default_value = 0) const {std::string str_value = getValue(key);return str_value.empty() ? default_value : std::stoi(str_value);}bool getBoolValue(const std::string& key, bool default_value = false) const {std::string str_value = getValue(key);return str_value == "true" || str_value == "1";}
};

5.3 永不銷毀的單例（特殊場景）

template <typename T>
class NeverDestroySingleton {
public:NeverDestroySingleton(const NeverDestroySingleton&) = delete;NeverDestroySingleton& operator=(const NeverDestroySingleton&) = delete;static T& getInstance() {static T* instance = new T();  // 永遠不會被析構return *instance;}protected:NeverDestroySingleton() = default;~NeverDestroySingleton() = default;
};

使用場景：

• 防止靜態析構順序問題
• 程序退出時必須保持可用的組件（如日志系統）

注意： 這種方式會導致內存"泄漏"，但在某些場景下是可接受的。

---

6. 總結與選擇指南

6.1 各種實現方式對比

實現方式	線程安全	性能	內存管理	復雜度	推薦指數
樸素實現	?	?????	?	?	?
加鎖版本	?	??	?	??	?
Meyers單例	?	?????	?	?	?????
單例模板	?	?????	?	??	?????
安全DCLP	?	????	?	????	???

6.2 選擇建議

🎯 通用場景（90%的情況）

推薦：Meyers單例或單例模板

class MyClass : public Singleton<MyClass> {friend class Singleton<MyClass>;// 實現...
};

🎯 高并發系統

推薦：安全DCLP + atomic

• 網絡服務器
• 游戲引擎
• 實時系統

🎯 特殊需求

• 需要延遲銷毀：NeverDestroy單例
• 需要Mock測試：依賴注入替代單例
• 跨DLL使用：特殊處理或避免使用

6.3 使用注意事項

? 最佳實踐

1. 優先使用Meyers單例（局部靜態變量）
2. 總是禁止拷貝構造和賦值操作
3. 考慮使用模板提高代碼復用性
4. 在構造函數中完成所有初始化工作
5. 注意異常安全性

? 常見誤區

1. 不要手動管理單例的生命周期
2. 不要在單例的析構函數中訪問其他單例
3. 避免在單例中使用其他單例（循環依賴）
4. 不要將單例用作全局變量的替代品

6.4 代碼模板（直接使用）

// 文件：singleton.h
#pragma once
#include <mutex>
#include <memory>// 通用單例模板
template <typename T>
class Singleton {
public:Singleton(const Singleton&) = delete;Singleton& operator=(const Singleton&) = delete;Singleton(Singleton&&) = delete;Singleton& operator=(Singleton&&) = delete;static T& getInstance() {static T instance;return instance;}protected:Singleton() = default;virtual ~Singleton() = default;
};// 使用宏簡化定義（可選）
#define SINGLETON_CLASS(ClassName) \friend class Singleton<ClassName>; \private: \ClassName(); \~ClassName() = default;

---