Using `std::call_once` for lazy initialization

Briefly, I have a class that lazily initializes one of its data members and I'd like to figure out the best way to do this in a multithreaded environment.

In more detail, my class currently looks something like this:

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

class A_single_threaded
{
public:
   bool query(const int val) const
   {
      // if opt_vec is not initialized, do that now
      if (!(opt_vec.has_value()))
         initialize_vec();

      // return true if opt_vec contains val
      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;

   // sets opt_vec
   void initialize_vec() const;
};

initialize_vec is the only method that modifies opt_vec, and query is the only method that calls initialize_vec. opt_vec can potentially be empty after initialize_vec returns, so giving the data member std::optional type helps distinguish when it's unset and when it's set and empty. In other instances opt_vec winds up being large and initializing it is time-consuming. And since not every A_single_threaded instance will need to run query anyway, it makes sense to avoid initializing opt_vec until a user call to query makes clear that initialization is necessary.

The approach above seems OK for a single thread, but I think it isn't naturally multithread-able. The calls to opt_vec.has_value() and initialize_vec are necessarily unsynchronized, and the gap between their return times allows for a data race that I don't think can be fixed with a mutex. Instead I think the correct solution involves replacing the std::optional with std::call_once, something like the below:

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

class A_multi_threaded
{
public:
   bool query(const int val) const
   {
      // if opt_vec is not initialized, do that now
      std::call_once(opt_vec_flag, initialize_vec, this);

      // return true if opt_vec contains val
      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;

   // sets opt_vec
   void initialize_vec() const;
};

I'd appreciate answers to a couple of questions:

1. Is the implementation I sketched for A_multi_threaded actually thread-safe?
2. Will A_multi_threaded have the same behavior as A_single_threaded in a single-threaded environment?
3. Is there a sensible implementation of A_multi_threaded that mimics the implementation of A_single_threaded?