基于std::call_once的懒初始化多线程实现技术问询

单线程实现 #

#include <algorithm>
#include <optional>
#include <vector>

class A_single_threaded
{
public:
   bool query(const int val) const
   {
      // 若opt_vec未初始化，执行初始化
      if (!(opt_vec.has_value()))
         initialize_vec();

      // 返回val是否存在于opt_vec中
      return std::find(std::cbegin(opt_vec), std::cend(opt_vec), val) != std::cend(opt_vec);
   }
private:
   mutable std::optional<std::vector<int>> opt_vec;

   // 初始化opt_vec
   void initialize_vec() const;
};

该单线程实现中，initialize_vec是唯一修改opt_vec的方法，query是唯一调用initialize_vec的方法。std::optional用于区分未初始化和已初始化但为空vector两种状态。由于初始化操作耗时，且并非所有实例都会调用query，因此采用懒初始化方案。

但该实现无法直接用于多线程环境：判断opt_vec.has_value()与调用initialize_vec的间隙存在数据竞争，单纯用互斥锁也无法完美解决（会导致不必要的锁开销）。尝试用std::call_once改写为多线程版本：

多线程实现尝试 #

#include <algorithm>
#include <mutex>
#include <vector>

class A_multi_threaded
{
public:
   bool query(const int val) const
   {
      // 确保initialize_vec仅执行一次
      std::call_once(opt_vec_flag, initialize_vec, this);

      // 返回val是否存在于opt_vec中
      return std::find(std::cbegin(opt_vec), std::cend(opt_vec), val) != std::cend(opt_vec);
   }
private:
   mutable std::vector<int> opt_vec;
   mutable std::once_flag opt_vec_flag;

   // 初始化opt_vec
   void initialize_vec() const;
};

问题1：上述A_multi_threaded实现是否真的线程安全？ #

是完全线程安全的。std::call_once是C++标准提供的线程原语，核心语义就是保证传入的可调用对象（此处为initialize_vec）仅被执行一次：

• 所有调用std::call_once的线程会阻塞，直到初始化操作完成；
• 标准同时规定std::call_once会建立内存屏障，确保initialize_vec对opt_vec的修改对所有后续访问opt_vec的线程可见，不存在内存可见性问题；
• 由于initialize_vec仅执行一次，不存在多线程同时修改opt_vec的场景，只要initialize_vec本身的逻辑是线程安全的（此处它只修改当前实例的opt_vec，无跨实例共享数据），整个实现就没有线程安全隐患。

问题2：单线程环境下，A_multi_threaded与A_single_threaded行为是否一致？ #

从外部可观察行为来看是一致的，但内部状态表示存在差异：

• 两者的query方法表现完全相同：第一次调用会触发initialize_vec执行，后续调用直接使用初始化后的vector进行查询，返回结果一致；
• 差异在于内部状态：原单线程用std::optional区分“未初始化”和“已初始化但空vector”，而多线程版本的opt_vec初始就是空vector，无法区分这两种状态。但如果没有额外方法暴露这个内部状态差异，外部调用者无法感知，因此核心行为一致。

问题3：是否存在贴近原单线程实现的合理A_multi_threaded实现方案？ #

存在，可以保留std::optional的状态区分能力，同时用**双重检查锁定（Double-Checked Locking）**保证线程安全（C++11及以后内存模型支持）：

#include <algorithm>
#include <mutex>
#include <optional>
#include <vector>

class A_multi_threaded
{
public:
   bool query(const int val) const
   {
      // 第一次无锁检查：快速路径，避免每次调用都加锁
      if (!opt_vec.has_value())
      {
         std::lock_guard<std::mutex> lock(vec_mutex);
         // 第二次加锁检查：确保只有第一个进入临界区的线程执行初始化
         if (!opt_vec.has_value())
         {
            initialize_vec();
         }
      }

      return std::find(std::cbegin(*opt_vec), std::cend(*opt_vec), val) != std::cend(*opt_vec);
   }
private:
   mutable std::optional<std::vector<int>> opt_vec;
   mutable std::mutex vec_mutex;

   void initialize_vec() const;
};

这个方案完全保留了原单线程的结构：

• 用std::optional维持“未初始化”和“已初始化但空”的状态区分；
• 双重检查锁定既保证了线程安全，又避免了每次调用query都加锁的性能开销；
• std::mutex的加解锁操作会建立内存屏障，确保初始化后的opt_vec状态对所有线程可见，符合C++11及以后的内存模型要求。

另外，C++20及以后也可以用std::atomic<std::optional<std::vector<int>>>实现无锁的懒初始化，但双重检查锁定方案兼容性更好，更贴近原单线程的实现逻辑。

内容的提问来源于stack exchange，提问作者Dimitrije Kostic