如何在 C++ 中实现一个线程安全的懒加载单例模式

作者

在 C++11 之后，标准库提供了多种支持线程安全的机制，使得实现线程安全的懒加载单例变得既简单又高效。本文从设计原则、实现方式以及性能优化三个方面，详细阐述如何在实际项目中正确使用单例模式。

1. 设计原则

  1. 单一实例：保证在整个程序生命周期中，单例类只产生一个对象。
  2. 延迟初始化：对象在第一次使用时才创建，避免无谓的资源占用。
  3. 线程安全：在多线程环境下，同一时刻只能创建一次实例。
  4. 易于使用：提供静态 getInstance() 方法即可访问实例，使用者无需关注内部细节。

2. 实现方式

2.1 使用 std::call_once

C++11 引入的 std::call_once 与 std::once_flag 可以确保某段代码只执行一次，并且在多线程环境下是安全的。以下是最常见的实现方式：

#include <iostream>
#include <mutex>

class Singleton {
public:
    static Singleton& getInstance() {
        std::call_once(initFlag_, [](){
            instance_.reset(new Singleton);
        });
        return *instance_;
    }

    // 禁止拷贝构造和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    void sayHello() const {
        std::cout << "Hello from Singleton instance!\n";
    }

private:
    Singleton() { std::cout << "Singleton constructor\n"; }
    ~Singleton() { std::cout << "Singleton destructor\n"; }

    static std::unique_ptr <Singleton> instance_;
    static std::once_flag initFlag_;
};

std::unique_ptr <Singleton> Singleton::instance_ = nullptr;
std::once_flag Singleton::initFlag_;

优点：

  • 代码简洁，易于维护。
  • std::call_once 本身使用 std::mutex 保护，性能可靠。

2.2 静态局部变量（C++11 之后）

C++11 之后，局部静态变量的初始化是线程安全的。利用这一特性可以进一步简化实现：

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance; // C++11 线程安全初始化
        return instance;
    }

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

    void sayHello() const { std::cout << "Hello from Singleton!\n"; }

private:
    Singleton() { std::cout << "Singleton constructed\n"; }
    ~Singleton() { std::cout << "Singleton destroyed\n"; }
};

优点：

  • 代码最短，编译器自动保证线程安全。
  • 延迟初始化，且只在第一次调用 getInstance() 时创建。

注意：若你需要在销毁时执行一些资源释放，最好使用 std::unique_ptr 或者 std::shared_ptr，因为静态局部变量的销毁顺序可能导致依赖问题。

3. 性能优化

在高并发场景下，std::call_once 的锁实现可能会成为瓶颈。若你确定单例只在程序启动阶段创建，后续不再创建新实例，可以采用以下策略：

  1. 双重检查锁（Double-Checked Locking）：适用于单例创建后不再销毁的情况。
class Singleton {
public:
    static Singleton* getInstance() {
        if (!instance_) {                     // 第一层检查
            std::lock_guard<std::mutex> lock(mutex_);
            if (!instance_) {                 // 第二层检查
                instance_ = new Singleton();
            }
        }
        return instance_;
    }

    // 其它成员...

private:
    Singleton() {}
    static Singleton* instance_;
    static std::mutex mutex_;
};

Singleton* Singleton::instance_ = nullptr;
std::mutex Singleton::mutex_;

警告：在 C++11 之前，Singleton* instance_ 需要使用 std::atomic<Singleton*> 或 volatile 来防止指令重排导致的未初始化访问。C++11 之后，使用 std::atomic 或者 std::memory_order 可以更安全。

  1. 使用 std::once_flag 结合 std::atomic_flag：更细粒度的控制。

4. 单例与 RAII 的结合

在现代 C++ 中，推荐使用 std::shared_ptr 或 std::unique_ptr 管理单例对象，并在内部使用 std::weak_ptr 避免循环引用：

class Singleton {
public:
    static std::shared_ptr <Singleton> getInstance() {
        static std::weak_ptr <Singleton> weakInstance;
        std::shared_ptr <Singleton> sharedInstance = weakInstance.lock();
        if (!sharedInstance) {
            std::lock_guard<std::mutex> lock(mutex_);
            sharedInstance = weakInstance.lock();
            if (!sharedInstance) {
                sharedInstance = std::shared_ptr <Singleton>(new Singleton);
                weakInstance = sharedInstance;
            }
        }
        return sharedInstance;
    }

    // ...

private:
    Singleton() {}
    static std::mutex mutex_;
};

std::mutex Singleton::mutex_;

这种实现方式可以在程序结束时自动释放单例资源，避免程序结束时资源泄露或析构顺序问题。

5. 小结

  • std::call_once 与 静态局部变量 是实现线程安全懒加载单例最推荐的方法。
  • 对于极端高并发环境，可以采用双重检查锁或 std::atomic_flag 进一步优化。
  • 利用 RAII（std::shared_ptr / std::unique_ptr）可自动管理资源，降低错误风险。

通过上述技巧，你可以在 C++ 项目中轻松实现既安全又高效的单例模式，为全局配置、日志系统、资源池等场景提供稳固的基础。

发表评论