【C/C++】线程安全初始化：std::call_once详解

std::call_once 使用详解

std::call_once 是 C++11 尺度库中提供的一个线程安全的一次性调用机制，位于 <mutex> 头文件中。它确保某个可调用对象只被实行一次，纵然多个线程同时实验调用它。
基本用法

1. #include <mutex>
2. #include <thread>
4. std::once_flag flag; // 全局或静态的once_flag
6. void initialize() {
7.     // 初始化代码（只执行一次）
8. }
10. void thread_function() {
11.     std::call_once(flag, initialize);
12. }
14. int main() {
15.     std::thread t1(thread_function);
16.     std::thread t2(thread_function);
17.     t1.join();
18.     t2.join();
19. }

复制代码

焦点组件

• std:nce_flag
  
  
  
  • 轻量级对象，用于标志函数是否已被调用
    
  • 必须黑白局部的（全局/静态/类静态成员）
    
  • 不可复制、不可移动、不可赋值
    
  
  
• std::call_once
  
  
  
  • 函数模板：template <class Callable, class... Args> void call_once(once_flag& flag, Callable&& func, Args&&... args);
    
  • 保证 func 只实行一次
    
  • 线程安全：其他线程会壅闭直到初始化完成
    
  
  

关键特性

• 线程安全保证：
  
  
  
  • 只有一个线程会实行函数
    
  • 其他线程会壅闭直到函数实行完成
    
  • 实行完成后，所有线程都能看到初始化效果
    
  
  
• 非常处理惩罚：
  
  
  
  • 如果函数抛出非常，非常会流传给调用者
    
  • once_flag 不会被标志为完成，其他线程会重试实行
    
  • 需要确保函数在重试时能成功
    
  
  
• 性能特点：
  
  
  
  • 初始化完成后只有原子检查的开销
    
  • 初始化期间其他线程会壅闭
    
  • 比双重检查锁定更简单安全
    
  
  

使用场景

1. 延迟初始化（Lazy Initialization）

1. class ExpensiveResource {
2. public:
3.     static ExpensiveResource& getInstance() {
4.         static std::once_flag initFlag;
5.         std::call_once(initFlag, [] {
6.             instance.reset(new ExpensiveResource());
7.         });
8.         return *instance;
9.     }
11. private:
12.     static std::unique_ptr<ExpensiveResource> instance;
13.     ExpensiveResource() { /* 耗时的初始化 */ }
14. };

复制代码

延迟初始化，使用static Singleton instance; return instance;形式更优
2. 线程安全的单例模式

1. class Logger {
2. public:
3.     static Logger& getInstance() {
4.         static std::once_flag flag;
5.         std::call_once(flag, [] {
6.             instance.reset(new Logger());
7.         });
8.         return *instance;
9.     }
11.     void log(const std::string& message) {
12.         std::lock_guard<std::mutex> lock(mutex);
13.         // 线程安全的日志记录
14.     }
16. private:
17.     static std::unique_ptr<Logger> instance;
18.     std::mutex mutex;
19.     Logger() = default;
20. };

复制代码

3. 初始化共享资源

1. class DatabaseConnection {
2. public:
3.     static DatabaseConnection& getConnection() {
4.         static std::once_flag initFlag;
5.         std::call_once(initFlag, &DatabaseConnection::init, this);
6.         return *this;
7.     }
9. private:
10.     void init() {
11.         // 建立数据库连接
12.     }
13. };

复制代码

4. 一次性配置加载

1. class Config {
2. public:
3.     static const Config& load() {
4.         static std::once_flag flag;
5.         static Config instance;
6.         std::call_once(flag, [] {
7.             instance.loadFromFile("config.json");
8.         });
9.         return instance;
10.     }
12. private:
13.     void loadFromFile(const std::string& path) {
14.         // 从文件加载配置
15.     }
16. };

复制代码

5. 插件体系初始化

1. class PluginManager {
2. public:
3.     void initialize() {
4.         std::call_once(initFlag, [this] {
5.             loadPlugins();
6.             registerHooks();
7.             initEventSystem();
8.         });
9.     }
11. private:
12.     std::once_flag initFlag;
13. };

复制代码

与局部静态变量的对比

特性std::call_once局部静态变量 (C++11+)语法复杂度较复杂简单控制粒度精细控制整个函数多位置调用支持多个位置调用雷同初始化只能在一个位置初始化成员函数初始化可直接用于成员函数只能用于静态成员或全局函数初始化参数可传递参数无参数多次初始化差异函数支持不支持性能初始化后开销小雷同非常处理惩罚显式处理惩罚，可重试编译器处理惩罚最佳实践

• 只用于真正的"一次性"操纵：不要用于大概多次初始化的场景
  
• 避免在性能关键路径使用：初始化期间会壅闭其他线程
  
• 确保函数幂等性：纵然多次调用也不会产生副作用（考虑非常情况）
  
• 配合智能指针管理资源：避免资源泄漏
  
• 谨慎处理惩罚非常：确保在重试时能成功完成初始化
  
• 避免递归调用：不要在call_once的函数内再次调用call_once
  

错误用法示例

1. // 错误1：局部once_flag（每次调用都会新建）
2. void unsafe_init() {
3.     std::once_flag flag; // 错误！每次调用都是新的flag
4.     std::call_once(flag, []{ /* ... */ });
5. }
7. // 错误2：尝试多次初始化
8. void double_init() {
9.     static std::once_flag flag;
10.     std::call_once(flag, []{ /* 初始化A */ });
11.     std::call_once(flag, []{ /* 初始化B */ }); // 永远不会执行
12. }
14. // 错误3：异常处理不当
15. void risky_init() {
16.     static std::once_flag flag;
17.     std::call_once(flag, []{
18.         if (/* 条件 */) {
19.             throw std::runtime_error("Oops");
20.         }
21.     }); // 抛出异常后flag未标记，其他线程会重试
22. }

复制代码

总结

std::call_once 是 C++ 中实现线程安全一次性初始化的强大工具，特别适用于：

• 延迟初始化昂贵资源
  
• 实现线程安全的单例
  
• 加载配置或资源
  
• 初始化共享状态
  

相比于传统的双重检查锁定模式，std::call_once 提供了更简便、更安全的替代方案，避免了复杂的同步逻辑和潜伏的内存排序题目。在 C++11 及以上情况中，它是实现线程安全初始化的紧张工具。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告