如何仅在任务成功后触发std::once_flag，消除冗余初始化校验？

问题背景 #

需要实现满足以下要求的并发初始化逻辑：

• 初始化操作仅需成功执行一次，支持并发调用
• 执行初始化前必须完成路径有效性校验（std::filesystem::exists()）
• 初始化成功后，后续调用需直接跳过校验与初始化流程
• 无法修改调用方逻辑，初始化路径由调用方动态传入
• 移除示例中额外的g_init原子变量，避免冗余状态

核心痛点 #

std::once_flag的局限性在于：一旦std::call_once进入回调逻辑，无论初始化成功与否，都会标记flag为已调用，无法区分"初始化成功"和"校验失败/初始化异常"的场景。因此需要自定义逻辑，仅在初始化真正成功后才标记完成状态。

方案1：C++11+ 双重检查锁（DCLP）实现一次性成功初始化 #

这是最简洁的兼容方案，用单个原子变量做快速检查，结合互斥锁确保只有一个线程执行校验与初始化：

#include <mutex>
#include <filesystem>
#include <atomic>
#include "fmt/core.h"
#include "nlohmann/json.hpp"
using json = nlohmann::json;

std::atomic<bool> g_inited = false;
std::mutex g_init_mutex;

void doOnce(std::string path) {
    // 实际初始化逻辑
    fmt::print("initialization done\n");
}

void doWork(json& cfg) {
    // 快速路径：已初始化直接返回，避免锁竞争
    if (g_inited.load(std::memory_order_acquire)) {
        fmt::print("already inited\n");
        return;
    }

    // 加锁进入慢路径，确保只有一个线程执行校验与初始化
    std::lock_guard<std::mutex> lock(g_init_mutex);

    // 双重检查：防止加锁期间其他线程已完成初始化
    if (g_inited.load(std::memory_order_relaxed)) {
        fmt::print("already inited\n");
        return;
    }

    // 仅当前线程执行校验与初始化
    std::string path = cfg["PATH"];
    if (!std::filesystem::exists(path)) {
        fmt::print("load failed\n");
        return;
    }

    doOnce(std::move(path));
    // 初始化成功后标记状态，后续所有调用直接跳过
    g_inited.store(true, std::memory_order_release);
}

说明：

• 原子变量g_inited作为快速检查标记，避免无意义的锁竞争
• 双重检查确保只有第一个进入的线程执行校验与初始化
• 仅当校验通过且初始化完成后，才设置g_inited为true，完全符合需求

方案2：C++20 原子可选值（std::atomic<std::optional>） #

利用C++20引入的原子化std::optional，存储成功初始化的路径，同时作为初始化完成的标记：

#include <mutex>
#include <filesystem>
#include <atomic>
#include <optional>
#include "fmt/core.h"
#include "nlohmann/json.hpp"
using json = nlohmann::json;

std::once_flag g_init_flag;
std::atomic<std::optional<std::string>> g_valid_path;

void doOnce(std::string path) {
    // 实际初始化逻辑
    fmt::print("initialization done\n");
    // 初始化成功后存储有效路径，标记完成状态
    g_valid_path.store(std::move(path), std::memory_order_release);
}

void doWork(json& cfg) {
    // 快速检查：已存储有效路径则直接返回
    if (g_valid_path.load(std::memory_order_acquire).has_value()) {
        fmt::print("already inited\n");
        return;
    }

    std::string path = cfg["PATH"];
    if (!std::filesystem::exists(path)) {
        fmt::print("load failed\n");
        return;
    }

    // 确保只有一个线程执行初始化逻辑
    std::call_once(g_init_flag, [path = std::move(path)]() {
        doOnce(std::move(path));
    });

    // 再次检查：防止当前线程被其他线程抢先完成初始化
    if (!g_valid_path.load(std::memory_order_acquire).has_value()) {
        return;
    }
}

说明：

• g_valid_path既存储初始化用的有效路径，又作为初始化完成的标记
• std::call_once保证只有一个线程进入初始化逻辑，避免重复初始化
• 原子操作确保多线程下状态读取的一致性

方案3：C++20 std::shared_future 支持多路径重试 #

如果需要支持调用方传入不同路径，直到某一次初始化成功，可以用std::shared_future共享初始化结果：

#include <future>
#include <filesystem>
#include "fmt/core.h"
#include "nlohmann/json.hpp"
using json = nlohmann::json;

std::shared_future<bool> g_init_future;
std::mutex g_init_mutex;

bool tryInit(std::string path) {
    if (!std::filesystem::exists(path)) {
        fmt::print("load failed\n");
        return false;
    }
    fmt::print("initialization done\n");
    return true;
}

void doWork(json& cfg) {
    // 快速检查：初始化已成功则直接返回
    if (g_init_future.valid() && g_init_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
        if (g_init_future.get()) {
            fmt::print("already inited\n");
            return;
        }
        // 初始化失败时，重置future允许后续线程重试
        g_init_future = {};
    }

    std::lock_guard<std::mutex> lock(g_init_mutex);

    // 再次检查，避免加锁期间其他线程已完成初始化
    if (g_init_future.valid() && g_init_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
        if (g_init_future.get()) {
            fmt::print("already inited\n");
            return;
        }
        g_init_future = {};
    }

    // 尝试初始化并共享结果
    std::promise<bool> init_promise;
    g_init_future = init_promise.get_future().share();
    bool success = tryInit(cfg["PATH"]);
    init_promise.set_value(success);
}

说明：

• std::shared_future让所有线程共享初始化结果，避免重复执行
• 初始化失败时重置future，允许后续线程尝试其他路径
• 适合调用方可能传入不同路径，直到找到有效路径的场景

内容的提问来源于stack exchange，提问作者Louis Go