C++怎么利用std::call_once确保初始化一次？多线程环境单例安全加载方法详解

在C++多线程开发中，单例模式的初始化安全是常见的问题，多个线程同时尝试获取单例实例时，很可能会触发多次初始化逻辑，破坏单例的唯一性。std::call_once作为C++11引入的标准库工具，能够完美解决这个问题，保证目标初始化操作只执行一次。

std::call_once的基本定义

std::call_once定义在<mutex>头文件中，它的作用是调用一个可调用对象，并且保证这个可调用对象在多线程环境下只会被执行一次。它的函数签名如下：

#include <mutex>

// once_flag是标识，用来标记对应的初始化是否已经执行过
std::once_flag flag;

// 调用形式，args是传递给可调用对象func的参数
template<class Callable, class... Args>
void call_once(std::once_flag& flag, Callable&& func, Args&&... args);

其中<std::once_flag>是一个不可复制、不可移动的对象，每个需要保证单次初始化的场景都需要对应一个独立的<std::once_flag>实例。

多线程单例的安全实现案例

下面通过一个懒加载的单例模式案例，演示如何使用std::call_once保证初始化只执行一次：

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

class Singleton {
private:
    // 私有构造函数，防止外部直接实例化
    Singleton() {
        std::cout << "Singleton 初始化完成" << std::endl;
    }

    // 静态的单例实例指针
    static Singleton* instance;
    // 静态的once_flag，用于标记初始化状态
    static std::once_flag init_flag;

    // 实际的初始化函数
    static void init_instance() {
        instance = new Singleton();
    }

public:
    // 获取单例实例的静态方法
    static Singleton* get_instance() {
        // 调用call_once，保证init_instance只执行一次
        std::call_once(init_flag, init_instance);
        return instance;
    }

    // 示例方法
    void do_something() {
        std::cout << "执行单例方法" << std::endl;
    }

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

// 静态成员类外初始化
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::init_flag;

// 线程执行的任务函数
void thread_task(int thread_id) {
    Singleton* s = Singleton::get_instance();
    std::cout << "线程" << thread_id << "获取单例地址: " << s << std::endl;
    s->do_something();
}

int main() {
    std::vector<std::thread> threads;
    // 创建5个线程同时获取单例
    for (int i = 0; i < 5; i++) {
        threads.emplace_back(thread_task, i);
    }
    // 等待所有线程执行完成
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

运行上述代码后，你会发现无论多少个线程同时调用<get_instance>方法，Singleton的构造函数只会执行一次，所有线程获取到的都是同一个实例地址，避免了重复初始化的问题。

std::call_once的核心特性

• 线程安全：C++标准保证std::call_once的调用是线程安全的，不需要额外加锁。
• 单次执行：只要<once_flag>没有被标记为已执行，多个线程竞争调用时，只有一个线程会执行初始化函数，其他线程会阻塞等待初始化完成。
• 异常安全：如果初始化函数执行时抛出异常，那么这次调用会被视为没有执行成功，后续的call_once调用会再次尝试执行初始化函数。

使用注意事项

once_flag的生命周期

<std::once_flag>的生命周期必须长于所有调用<std::call_once>的线程，通常将其定义为静态变量或者全局变量，避免在线程还在运行时<once_flag>被销毁。

避免重复定义once_flag

每个需要单次初始化的逻辑对应一个独立的<once_flag>，不要多个不同的初始化逻辑共用同一个<once_flag>，否则会导致部分初始化逻辑不会执行。

初始化函数的参数传递

传递给<std::call_once>的初始化函数的参数，会被完美转发，支持传递任意数量和类型的参数，不需要额外的包装。

与普通加锁实现的对比

传统的单例安全初始化可以通过互斥锁实现，比如双重检查锁定模式，但是双重检查锁定在C++11之前很容易出现内存可见性问题，而std::call_once由标准库保证正确性，使用起来更简单，也不容易出错。下面是双重检查锁定的实现示例，对比可以看出std::call_once的简洁性：

#include <mutex>

class SingletonWithLock {
private:
    SingletonWithLock() {}
    static SingletonWithLock* instance;
    static std::mutex mtx;

public:
    static SingletonWithLock* get_instance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx);
            if (instance == nullptr) {
                instance = new SingletonWithLock();
            }
        }
        return instance;
    }
};

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

可以看到，使用std::call_once的实现代码更简洁，也不需要手动处理锁的逻辑，降低了出错的概率。

std::call_once单例模式多线程C++11修改时间：2026-06-23 14:51:42