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

std::call_once 使用详解

std::call_once 是 C++11 标准库中提供的一个线程安全的一次性调用机制，位于 <mutex> 头文件中。它确保某个可调用对象只被执行一次，即使多个线程同时尝试调用它。

基本用法

#include <mutex>
#include <thread>

std::once_flag flag; // 全局或静态的once_flag

void initialize() {
    // 初始化代码（只执行一次）
}

void thread_function() {
    std::call_once(flag, initialize);
}

int main() {
    std::thread t1(thread_function);
    std::thread t2(thread_function);
    t1.join();
    t2.join();
}

核心组件

1. std::once_flag

   • 轻量级对象，用于标记函数是否已被调用
   • 必须是非局部的（全局/静态/类静态成员）
   • 不可复制、不可移动、不可赋值

2. std::call_once

   • 函数模板：template <class Callable, class... Args> void call_once(once_flag& flag, Callable&& func, Args&&... args);
   • 保证 func 只执行一次
   • 线程安全：其他线程会阻塞直到初始化完成

关键特性

1. 线程安全保证：

   • 只有一个线程会执行函数
   • 其他线程会阻塞直到函数执行完成
   • 执行完成后，所有线程都能看到初始化结果

2. 异常处理：

   • 如果函数抛出异常，异常会传播给调用者
   • once_flag 不会被标记为完成，其他线程会重试执行
   • 需要确保函数在重试时能成功

3. 性能特点：

   • 初始化完成后只有原子检查的开销
   • 初始化期间其他线程会阻塞
   • 比双重检查锁定更简单安全

使用场景

1. 延迟初始化（Lazy Initialization）

class ExpensiveResource {
public:
    static ExpensiveResource& getInstance() {
        static std::once_flag initFlag;
        std::call_once(initFlag, [] {
            instance.reset(new ExpensiveResource());
        });
        return *instance;
    }

private:
    static std::unique_ptr<ExpensiveResource> instance;
    ExpensiveResource() { /* 耗时的初始化 */ }
};

延迟初始化，使用static Singleton instance; return instance;形式更优

2. 线程安全的单例模式

class Logger {
public:
    static Logger& getInstance() {
        static std::once_flag flag;
        std::call_once(flag, [] {
            instance.reset(new Logger());
        });
        return *instance;
    }

    void log(const std::string& message) {
        std::lock_guard<std::mutex> lock(mutex);
        // 线程安全的日志记录
    }

private:
    static std::unique_ptr<Logger> instance;
    std::mutex mutex;
    Logger() = default;
};

3. 初始化共享资源

class DatabaseConnection {
public:
    static DatabaseConnection& getConnection() {
        static std::once_flag initFlag;
        std::call_once(initFlag, &DatabaseConnection::init, this);
        return *this;
    }

private:
    void init() {
        // 建立数据库连接
    }
};

4. 一次性配置加载

class Config {
public:
    static const Config& load() {
        static std::once_flag flag;
        static Config instance;
        std::call_once(flag, [] {
            instance.loadFromFile("config.json");
        });
        return instance;
    }

private:
    void loadFromFile(const std::string& path) {
        // 从文件加载配置
    }
};

5. 插件系统初始化

class PluginManager {
public:
    void initialize() {
        std::call_once(initFlag, [this] {
            loadPlugins();
            registerHooks();
            initEventSystem();
        });
    }

private:
    std::once_flag initFlag;
};

与局部静态变量的对比

最佳实践

1. 只用于真正的"一次性"操作：不要用于可能多次初始化的场景
2. 避免在性能关键路径使用：初始化期间会阻塞其他线程
3. 确保函数幂等性：即使多次调用也不会产生副作用（考虑异常情况）
4. 配合智能指针管理资源：避免资源泄漏
5. 谨慎处理异常：确保在重试时能成功完成初始化
6. 避免递归调用：不要在call_once的函数内再次调用call_once

错误用法示例

// 错误1：局部once_flag（每次调用都会新建）
void unsafe_init() {
    std::once_flag flag; // 错误！每次调用都是新的flag
    std::call_once(flag, []{ /* ... */ });
}

// 错误2：尝试多次初始化
void double_init() {
    static std::once_flag flag;
    std::call_once(flag, []{ /* 初始化A */ });
    std::call_once(flag, []{ /* 初始化B */ }); // 永远不会执行
}

// 错误3：异常处理不当
void risky_init() {
    static std::once_flag flag;
    std::call_once(flag, []{
        if (/* 条件 */) {
            throw std::runtime_error("Oops");
        }
    }); // 抛出异常后flag未标记，其他线程会重试
}

总结

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

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

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