C++——單例模式的原理及實現 - stronger 詳情 - c++,設計模式,單例模式,開發語言,windows,HarmonyOS,後端開發技術博客領航者博客

單例模式是 創建型設計模式 的核心成員，其核心目標是：確保一個類在程序生命週期內僅有一個實例，並提供一個全局統一的訪問點。

在 C++ 開發中，單例模式廣泛應用於管理全局資源（如日誌、配置、數據庫連接池）、避免重複初始化（如重型對象）、維護全局狀態（如計數器）等場景。本文將從核心原理、實現方式、關鍵問題、適用場景等維度，全面解析 C++ 單例模式的設計與實踐。

一、單例模式的核心定義與特點

1.1 核心目標

唯一性：類的實例在整個程序中只能有一個，禁止外部通過 new、拷貝等方式創建多個實例。
全局訪問：提供一個靜態方法（如 getInstance()），讓程序任何地方都能便捷訪問該實例。
可控初始化：根據需求選擇“提前初始化”（餓漢式）或“延遲初始化”（懶漢式），平衡資源佔用與啓動速度。

1.2 核心設計約束（必須滿足）

要實現單例模式，需通過以下約束禁止“多實例”：

私有構造函數：private: Singleton() {}，禁止外部直接 new Singleton() 創建實例。
私有拷貝構造函數：private: Singleton(const Singleton&) = delete;（C++11），禁止拷貝實例。
私有賦值運算符：private: Singleton& operator=(const Singleton&) = delete;（C++11），禁止賦值實例。
靜態實例與全局訪問點：通過靜態成員變量存儲唯一實例，靜態成員方法提供訪問接口。

二、C++ 單例模式的常見實現方式

單例模式的實現核心矛盾是 “線程安全” 與 “性能/資源佔用” 的平衡。以下是 C++ 中最常用的 5 種實現方式，按推薦優先級排序：

2.1 推薦方案：Meyers 單例（C++11 局部靜態變量）

這是 目前最推薦的單例實現，由 C++ 大師 Scott Meyers 提出，藉助 C++11 標準的特性，實現了“簡單、線程安全、延遲初始化”的完美平衡。

核心原理

C++11 標準明確規定：局部靜態變量的初始化是線程安全的——當多個線程同時調用 getInstance() 時，編譯器會自動保證局部靜態變量 instance 僅被初始化一次，無需手動加鎖。

實現代碼

#include <iostream>

class Singleton {
public:
    // 3. 全局訪問點：返回唯一實例（C++11 線程安全）
    static Singleton& getInstance() {
        static Singleton instance;  // 局部靜態變量，僅初始化一次
        return instance;
    }

    // 業務方法（示例）
    void doSomething() {
        std::cout << "Meyers Singleton: " << this << std::endl;
    }

    // 2. 禁止拷貝和賦值（C++11 推薦用 delete）
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    // 1. 私有構造函數（禁止外部實例化）
    Singleton() {
        std::cout << "Singleton 構造（僅調用一次）" << std::endl;
    }

    // 私有析構函數（可選，防止外部 delete）
    ~Singleton() {
        std::cout << "Singleton 析構（程序退出時調用）" << std::endl;
    }
};

// 測試代碼
int main() {
    // 多線程調用也不會創建多個實例（C++11 線程安全）
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();

    s1.doSomething();  // 輸出地址相同
    s2.doSomething();

    return 0;
}

輸出結果

Singleton 構造（僅調用一次）
Meyers Singleton: 0x7f8a1b400008
Meyers Singleton: 0x7f8a1b400008
Singleton 析構（程序退出時調用）

核心優點

簡單高效：代碼極簡，無需手動管理線程安全和實例銷燬。
線程安全：C++11 標準保證局部靜態變量初始化的原子性，無數據競爭。
延遲初始化：實例在第一次調用 getInstance() 時才創建，避免提前佔用資源。
自動銷燬：程序退出時，局部靜態變量會自動調用析構函數，無內存泄漏風險。

適用場景

絕大多數日常開發場景（無特殊需求時，優先選擇此方案）。
不需要傳遞參數初始化、對啓動速度有要求的場景。

注意事項

兼容性：僅支持 C++11 及以上標準（目前主流編譯器均支持）。
析構順序：若多個單例存在依賴關係，析構順序可能不確定（需通過主動銷燬機制解決）。

2.2 餓漢式（提前初始化）

餓漢式的核心是 “提前創建實例”——在程序啓動時（全局變量初始化階段）就創建單例實例，無需延遲初始化。

實現代碼

#include <iostream>

class Singleton {
public:
    // 3. 全局訪問點：返回提前創建的實例
    static Singleton& getInstance() {
        return instance;  // 直接返回全局靜態實例
    }

    void doSomething() {
        std::cout << "Hungry Singleton: " << this << std::endl;
    }

    // 禁止拷貝和賦值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    // 1. 私有構造函數
    Singleton() {
        std::cout << "Hungry Singleton 構造（程序啓動時調用）" << std::endl;
    }

    ~Singleton() {
        std::cout << "Hungry Singleton 析構" << std::endl;
    }

    // 2. 全局靜態實例（程序啓動時初始化）
    static Singleton instance;
};

// 全局靜態實例初始化（類外定義，觸發構造函數）
Singleton Singleton::instance;

// 測試代碼
int main() {
    std::cout << "main 函數啓動" << std::endl;
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();

    s1.doSomething();
    s2.doSomething();

    return 0;
}

輸出結果

Hungry Singleton 構造（程序啓動時調用）
main 函數啓動
Hungry Singleton: 0x6020c8
Hungry Singleton: 0x6020c8
Hungry Singleton 析構

核心優點

線程安全：實例在程序啓動時（單線程初始化階段）創建，無多線程競爭問題。
性能最優：getInstance() 僅返回引用，無鎖開銷、無初始化判斷，訪問速度最快。
實現簡單：無需處理線程同步和延遲初始化邏輯。

核心缺點

資源浪費：若單例實例佔用大量資源（如內存、數據庫連接），且程序運行中可能未使用，會造成資源閒置。
初始化順序不確定：若多個餓漢式單例存在依賴（如 A 依賴 B 的實例），可能因初始化順序導致崩潰（全局變量初始化順序不可控）。

適用場景

單例實例佔用資源少、啓動時必須初始化的場景（如配置管理類）。
對訪問性能要求極高，無需延遲初始化的場景。

2.3 懶漢式（線程安全，互斥鎖）

懶漢式的核心是 “延遲初始化”——僅在第一次調用 getInstance() 時創建實例。為解決多線程安全問題，需通過互斥鎖（std::mutex）保護實例創建過程。

實現代碼

#include <iostream>
#include <mutex>  // 需包含互斥鎖頭文件

class Singleton {
public:
    // 3. 全局訪問點（加鎖保證線程安全）
    static Singleton* getInstance() {
        // 雙重檢查鎖定（DCLP）：減少鎖開銷
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx);  // 加鎖
            if (instance == nullptr) {
                instance = new Singleton();  // 僅第一次調用時創建實例
            }
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Lazy Singleton: " << this << std::endl;
    }

    // 主動銷燬接口（可選，解決堆內存泄漏）
    static void destroyInstance() {
        std::lock_guard<std::mutex> lock(mtx);
        if (instance != nullptr) {
            delete instance;
            instance = nullptr;
        }
    }

    // 禁止拷貝和賦值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    // 1. 私有構造函數
    Singleton() {
        std::cout << "Lazy Singleton 構造" << std::endl;
    }

    ~Singleton() {
        std::cout << "Lazy Singleton 析構" << std::endl;
    }

    // 2. 靜態成員變量（堆上存儲，延遲初始化）
    static Singleton* instance;
    static std::mutex mtx;  // 互斥鎖，保護實例創建
};

// 靜態成員變量初始化（類外定義）
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

// 測試代碼
int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();

    s1->doSomething();
    s2->doSomething();

    // 主動銷燬（若不調用，進程退出時操作系統會回收內存，但析構函數不會執行）
    Singleton::destroyInstance();

    return 0;
}

核心亮點：雙重檢查鎖定（DCLP）

第一次檢查 instance == nullptr：避免每次調用 getInstance() 都加鎖（大部分場景下實例已存在，直接返回），減少鎖開銷。
加鎖後第二次檢查 instance == nullptr：防止多個線程同時通過第一次檢查，導致創建多個實例。

核心優點

延遲初始化：僅在需要時創建實例，避免資源浪費。
線程安全：通過互斥鎖保證實例創建過程的原子性。

核心缺點

實現複雜：需手動管理鎖、實例銷燬，易出錯。
鎖開銷：第一次調用後仍有一次空判斷，但比每次加鎖高效。
內存泄漏風險：若忘記調用 destroyInstance()，堆上的實例不會調用析構函數（若析構函數需釋放資源，會導致資源泄漏）。
C++11 前的可見性問題：舊標準中，instance = new Singleton() 可能被編譯器重排（分配內存 → 賦值指針 → 調用構造函數），導致其他線程看到“半初始化”的實例。C++11 後可通過 std::atomic 解決，但會增加複雜度。

適用場景

C++11 前的舊項目（無法使用 Meyers 單例）。
需手動控制實例銷燬時機的場景（如釋放文件句柄、數據庫連接）。

2.4 帶參數的單例

默認單例無法傳遞參數初始化（如配置類需要讀取配置文件路徑），需對核心邏輯改造，支持參數傳遞。

實現代碼（基於 Meyers 單例擴展）

#include <iostream>
#include <string>
#include <mutex>

class ConfigSingleton {
public:
    // 全局訪問點：支持傳遞參數（僅第一次調用有效）
    static ConfigSingleton& getInstance(const std::string& config_path = "") {
        static ConfigSingleton instance(config_path);  // 傳遞參數初始化
        return instance;
    }

    // 獲取配置（示例業務方法）
    std::string getConfig() const {
        return config_;
    }

    // 禁止拷貝和賦值
    ConfigSingleton(const ConfigSingleton&) = delete;
    ConfigSingleton& operator=(const ConfigSingleton&) = delete;

private:
    // 帶參數的私有構造函數
    explicit ConfigSingleton(const std::string& config_path) {
        // 模擬讀取配置文件
        if (config_path.empty()) {
            config_ = "默認配置";
        } else {
            config_ = "從路徑 " + config_path + " 加載的配置";
        }
        std::cout << "ConfigSingleton 構造：" << config_ << std::endl;
    }

    ~ConfigSingleton() {
        std::cout << "ConfigSingleton 析構" << std::endl;
    }

    std::string config_;  // 配置數據
};

// 測試代碼
int main() {
    // 第一次調用：傳遞參數初始化
    ConfigSingleton& config1 = ConfigSingleton::getInstance("./config.json");
    std::cout << "config1: " << config1.getConfig() << std::endl;

    // 後續調用：參數無效，返回已創建的實例
    ConfigSingleton& config2 = ConfigSingleton::getInstance("./other.json");
    std::cout << "config2: " << config2.getConfig() << std::endl;

    return 0;
}

輸出結果

ConfigSingleton 構造：從路徑 ./config.json 加載的配置
config1: 從路徑 ./config.json 加載的配置
config2: 從路徑 ./config.json 加載的配置
ConfigSingleton 析構

關鍵説明

僅第一次調用 getInstance() 時，參數有效；後續調用的參數會被忽略（保證實例唯一性）。
若需強制參數必須傳遞（禁止默認值），可移除 config_path 的默認值，並在構造函數中檢查參數合法性。
線程安全：依賴 Meyers 單例的局部靜態變量初始化特性，仍為線程安全。

適用場景

單例實例需要初始化參數的場景（如配置類、數據庫連接池類）。

2.5 可自動銷燬的懶漢式（解決內存泄漏）

針對普通懶漢式“析構函數不執行”的問題，可通過 內部銷燬類 實現自動銷燬。

實現代碼

#include <iostream>
#include <mutex>

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx);
            if (instance == nullptr) {
                instance = new Singleton();
                // 創建銷燬器（全局靜態變量，程序退出時調用析構）
                static Destroyer destroyer;
            }
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Auto-Destroy Lazy Singleton: " << this << std::endl;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    // 內部銷燬類（友元，可訪問私有析構函數）
    class Destroyer {
    public:
        ~Destroyer() {
            // 程序退出時，銷燬單例實例
            if (Singleton::instance != nullptr) {
                delete Singleton::instance;
                Singleton::instance = nullptr;
                std::cout << "Destroyer 銷燬 Singleton" << std::endl;
            }
        }
    };

    Singleton() {
        std::cout << "Auto-Destroy Lazy Singleton 構造" << std::endl;
    }

    ~Singleton() {
        std::cout << "Auto-Destroy Lazy Singleton 析構" << std::endl;
    }

    static Singleton* instance;
    static std::mutex mtx;
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

// 測試代碼
int main() {
    Singleton* s1 = Singleton::getInstance();
    s1->doSomething();
    return 0;
}

輸出結果

Auto-Destroy Lazy Singleton 構造
Auto-Destroy Lazy Singleton: 0x7f9b3c400000
Auto-Destroy Lazy Singleton 析構
Destroyer 銷燬 Singleton

核心原理

內部 Destroyer 類是全局靜態變量，程序退出時會自動調用其析構函數。
Destroyer 是 Singleton 的友元（或通過全局訪問點），可安全刪除 instance，確保析構函數執行。

三、單例模式的關鍵問題與解決方案

3.1 線程安全問題

核心矛盾：多線程同時調用 getInstance() 時，可能創建多個實例。
解決方案：

優先使用 Meyers 單例（C++11 線程安全，無需手動處理）。
餓漢式（提前初始化，無多線程競爭）。
懶漢式加互斥鎖（雙重檢查鎖定，適合舊標準）。

3.2 內存泄漏問題

場景：堆上創建的單例實例（如普通懶漢式）未調用 delete，導致析構函數不執行（若析構需釋放資源，如文件句柄、數據庫連接，會造成資源泄漏）。
解決方案：

用局部靜態變量（Meyers 單例、餓漢式）：程序退出時自動銷燬，析構函數執行。
內部銷燬類（自動銷燬的懶漢式）：通過全局靜態銷燬器自動調用 delete。
主動銷燬接口（如 destroyInstance()）：手動控制銷燬時機（需確保僅調用一次）。

3.3 單例被破壞的場景與防護

單例的“唯一性”可能被以下方式破壞，需針對性防護：

（1）拷貝或賦值創建實例

破壞方式：Singleton s = Singleton::getInstance();（調用拷貝構造函數）。
防護方案：將拷貝構造函數和賦值運算符設為 delete（C++11）或私有且不實現（C++11 前）。

（2）繼承破壞單例

破壞方式：子類繼承單例類，並重寫構造函數，創建子類實例。
防護方案：

將單例類的析構函數設為 private（禁止繼承，因子類析構需訪問父類析構）。
用 final 關鍵字修飾單例類（C++11），禁止繼承：class Singleton final { ... }。

（3）反射破壞（C++ 中風險極低）

破壞方式：通過反射機制（如 dynamic_cast + 內存操作）繞過私有構造函數。
防護方案：C++ 無原生反射，且反射破壞需底層內存操作，實際開發中幾乎無需考慮；若需極致防護，可在構造函數中添加全局計數器，判斷是否已創建實例。

（4）多進程/多線程fork破壞

破壞方式：多進程場景中，fork() 會複製父進程的內存空間，導致子進程擁有獨立的單例實例。
防護方案：fork() 後，子進程重新初始化單例（或通過進程間通信同步實例狀態）。

3.4 初始化順序與依賴問題

問題：多個單例存在依賴（如 A 初始化需調用 B 的實例），若初始化順序不確定（如餓漢式的全局變量初始化順序），可能導致 A 初始化時 B 未創建，觸發崩潰。
解決方案：

用 Meyers 單例（延遲初始化）：A 初始化時調用 B 的 getInstance()，確保 B 先創建。
顯式初始化：提供 init() 接口，手動控制單例的初始化順序。

四、單例模式的適用場景與反場景

4.1 適用場景

單例模式適合管理 全局唯一、資源密集、需統一訪問 的對象：

日誌類：全局唯一的日誌器，所有模塊通過同一實例寫入日誌（避免多日誌文件衝突）。
配置管理類：加載全局配置（如數據庫地址、端口），所有模塊共享配置數據。
數據庫連接池：全局唯一的連接池，統一管理連接資源，避免重複創建連接。
全局計數器：統計程序運行狀態（如請求數、錯誤數），需全局統一計數。
緩存管理器：全局緩存實例，統一管理緩存的增刪改查。

4.2 反場景（不建議使用單例）

需要多個實例的場景：如多個數據庫連接（應使用連接池，而非單例連接）。
依賴注入優先的場景：單例會增加代碼耦合（全局訪問點導致模塊依賴單例類），若項目使用依賴注入（DI）框架，應通過注入方式傳遞實例，而非單例。
狀態頻繁變化的場景：單例的全局狀態易被多個模塊修改，導致狀態混亂（需加鎖保護，影響性能）。
單元測試困難的場景：單例的全局狀態會影響測試獨立性，需在每個測試用例前重置單例狀態（複雜度高）。

五、單例模式的優缺點

5.1 優點

唯一性保證：確保全局僅有一個實例，避免資源競爭和狀態不一致。
全局訪問：無需傳遞實例指針，簡化模塊間的資源共享。
資源優化：延遲初始化（如 Meyers 單例）避免提前佔用資源；提前初始化（如餓漢式）避免運行時初始化開銷。
生命週期可控：可手動或自動管理實例的創建與銷燬。

5.2 缺點

代碼耦合度高：全局訪問點導致模塊依賴單例類，不利於代碼解耦和重構。
單元測試困難：單例的全局狀態會影響測試獨立性，需額外處理測試環境的狀態重置。
線程安全開銷：懶漢式的鎖機制會增加少量性能開銷（Meyers 單例無此問題）。
擴展性差：單例類通常禁止繼承和多實例，後續若需多個實例（如多租户場景），需重構代碼。

六、進階：單例模式的替代方案

若單例的“高耦合”“難測試”問題影響項目架構，可考慮以下替代方案：

6.1 依賴注入（DI）

通過構造函數或接口將實例注入到需要的模塊，而非全局訪問。例如：

// 不使用單例：通過依賴注入傳遞配置實例
class Service {
private:
    Config& config_;
public:
    // 構造函數注入配置實例
    Service(Config& config) : config_(config) {}
    void doWork() { /* 使用 config_  */ }
};

// 調用方：創建配置實例，注入到 Service
int main() {
    Config config("./config.json");
    Service service(config);
    service.doWork();
    return 0;
}

優點：解耦模塊依賴，便於單元測試（可注入mock實例）。
適用場景：中大型項目，追求代碼可測試性和可擴展性。

6.2 全局靜態變量（不推薦）

方案：直接使用全局靜態變量（如 extern Config g_config;），替代單例。
缺點：無訪問控制（可被任意修改）、初始化順序不確定、無生命週期管理，僅適用於簡單場景。

6.3 局部單例（按上下文唯一）

方案：單例的唯一性不是“全局唯一”，而是“上下文唯一”（如每個線程一個實例）。
實現：用 thread_local 修飾靜態實例（C++11），確保每個線程有獨立實例：

static Singleton& getThreadLocalInstance() {
    thread_local Singleton instance;  // 每個線程獨立實例
    return instance;
}

適用場景：線程私有資源管理（如線程本地存儲 TLS）。

七、總結與推薦實踐

7.1 不同實現方式對比

實現方式	線程安全（C++11+）	延遲初始化	代碼複雜度	內存泄漏風險	推薦優先級
Meyers 單例（局部靜態）	是	是	極低	無	★★★★★
餓漢式（全局靜態）	是	否	低	無	★★★★☆
懶漢式（互斥鎖）	是	是	中	有（需手動銷燬）	★★★☆☆
帶參數的 Meyers 單例	是	是	低	無	★★★★☆

7.2 推薦實踐

日常開發首選：Meyers 單例（局部靜態變量），簡單、高效、線程安全，無內存泄漏。
需參數初始化：帶參數的 Meyers 單例（僅第一次調用傳遞參數）。
啓動時必須初始化：餓漢式（如配置類、日誌類），性能最優。
舊項目兼容：懶漢式（互斥鎖+雙重檢查），需注意銷燬機制。
高可擴展性需求：避免單例，使用依賴注入替代。

7.3 核心原則

單例是“必要之惡”：僅在確實需要全局唯一實例時使用，避免過度設計。
優先保證線程安全和無內存泄漏：選擇成熟的實現方式（如 Meyers 單例），避免手動管理鎖和銷燬邏輯。
防護單例破壞：必須禁用拷貝、賦值和繼承，確保唯一性。

通過以上內容，可全面掌握 C++ 單例模式的設計、實現與工程實踐，在實際開發中根據場景選擇合適的方案，平衡唯一性、性能和可擴展性。

本文章為轉載內容，我們尊重原作者對文章享有的著作權。如有內容錯誤或侵權問題，歡迎原作者聯繫我們進行內容更正或刪除文章。

博客 / 詳情