并发编程（8）—— std::async、std::future 源码解析

八、day8

之前说过，std::async内部的处理逻辑和std::thread相似，而且std::async和std::future有密不可分的联系。今天，通过对std::async和std::future源码进行解析，了解二者的处理逻辑和关系。

源码均基于 MSVC 实现

参考：

1. 博主恋恋风辰的个人博客
2. up主mq白cpp的个人仓库

1. std::async

std::async有两种重载实现：

template <class _Fty, class... _ArgTypes>
_NODISCARD future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args) {// manages a callable object launched with supplied policyusing _Ret   = _Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>;using _Ptype = typename _P_arg_type<_Ret>::type;_Promise<_Ptype> _Pr(_Get_associated_state<_Ret>(_Policy, _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(_STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...)));return future<_Ret>(_Pr._Get_state_for_future(), _Nil());
}template <class _Fty, class... _ArgTypes>
_NODISCARD future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(_Fty&& _Fnarg, _ArgTypes&&... _Args) {// manages a callable object launched with default policyreturn _STD async(launch::async | launch::deferred, _STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...);
}

第一种重载需要显式指定启动策略，也就是我们之前说的std::launch::async、std::launch::deferred和std::launch::async | std::launch::deferred；第二种重载在使用默认策略时会被调用（也就是只传递可调用对象和参数而不传递启动策略），在内部会调用第一种重载并传入一个std::launch::async | std::launch::deferred策略，并将参数全部转发。

我们只需要着重关注第一种重载即可：

1. 模板参数和函数体外部信息：

   • _Fty：可调用对象的类型
   • _ArgTypes：可调用对象所需的参数类型
   • _NODISCARD：宏，用于标记该函数的返回值不应被忽略

2. 返回类型：

   future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>>
   

   其实就是返回一个 std::future 对象，_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>是std::invoke对给定的可调用对象 _Fnarg 和参数 _Args... 执行后返回的类型，其实也就是通过 _Invoke_result_t 从 _Fty 和 _ArgTypes... 中推导出的返回类型。

   我们之前在thread源码解析中说过std::invoke内部其实是调用_Call函数，_Call函数负责提供参数并调用传入的可调用对象。

   我们可以把 _Invoke_result_t 看作是一个对 std::invoke 的结果类型的封装，std::invoke 是一个工具，可以调用可调用对象并返回其结果。_Invoke_result_t 提供了一种方式来“推导”出这个结果类型。

   这个类型萃取工具通常长这样（简化版）：

   template <typename _Callable, typename... _Args>
   struct _Invoke_result_t {using type = decltype(std::invoke(std::declval<_Callable>(), std::declval<_Args>()...));
   };
   

   上述代码通过 std::invoke 来推导（decltype） _Callable（即可调用对象）在给定参数 _Args... 上执行后的返回类型。换句话说，_Invoke_result_t<_Fty, _ArgTypes...> 的 type 成员类型就是可调用对象在调用后的返回类型。

   值得注意的是，所有类型在传递前都进行了 decay 处理，也就是将cv和const修饰符去掉，默认按值传递与 std::thread 的行为一致。

3. 形参：

   future<_Ret> async(launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args) {}
   

   • launch _Policy: 表示任务的执行策略，可以是 launch::async（表示异步执行）或 launch::deferred（表示延迟执行），或者std::launch::async | std::launch::deferred
   • _Fty&& _Fnarg: 可调用对象，通过完美转发机制将其转发给实际的异步任务
   • _ArgTypes&&... _Args: 调用该可调用对象时所需的参数，同样通过完美转发机制进行转发

4. _Ret和_Ptype ：

   • _Ret就算我们在返回类型中说到的_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>，表示可调用对象的返回类型；

   • using _Ptype = typename _P_arg_type<_Ret>::type：_Ptype 的定义在大多数情况下和 _Ret 是相同的，类模板 _P_arg_type 只是为了处理引用类型以及 void 的情况，参见 _P_arg_type 的实现：

     template <class _Fret>
     struct _P_arg_type { // type for functions returning Tusing type = _Fret;
     };template <class _Fret>
     struct _P_arg_type<_Fret&> { // type for functions returning reference to Tusing type = _Fret*;
     };template <>
     struct _P_arg_type<void> { // type for functions returning voidusing type = int;
     };
     

     为什么需要 _Ptype ？

     在异步任务的实现中，std::promise 是用于将结果与 std::future 绑定的对象。std::promise 的模板参数通常是可调用对象返回值的类型。在 std::async 函数中，我们需要创建一个 std::promise 对象来存储任务的结果，因此我们需要计算出正确的承诺类型（promise type）。也就是说，定义 _Ptype 是为了配合后面 _Promise 的使用，确保任务的结果可以通过 std::future 获取。

     • _Ret 是任务返回的类型（由 _Invoke_result_t 推导出）。

     • _Ptype 就是这个返回类型的承诺类型。也就是说，**_Ptype 是 std::promise 的模板参数类型，**表示这个任务结果的类型。

     _Ptype 的定义在大多数情况下和 _Ret 是相同的，都是可调用对象返回值的类型。

5. _Promise<_Ptype> _Pr：创建一个 std::promise 对象 _Pr，其类型为 _Ptype，表示与异步任务的结果相关联的承诺（promise）。_Promise类型我们之前讲过，这里就不在叙述它的作用，关键还在于其存储的数据成员：

   template <class _Ty>
   class _Promise {
   public:_Promise(_Associated_state<_Ty>* _State_ptr) : _State(_State_ptr, false), _Future_retrieved(false) {}_Promise(_Promise&& _Other) : _State(_STD move(_Other._State)), _Future_retrieved(_Other._Future_retrieved) {}_Promise& operator=(_Promise&& _Other) {_State            = _STD move(_Other._State);_Future_retrieved = _Other._Future_retrieved;return *this;}~_Promise() noexcept {}void _Swap(_Promise& _Other) {_State._Swap(_Other._State);_STD swap(_Future_retrieved, _Other._Future_retrieved);}const _State_manager<_Ty>& _Get_state() const {return _State;}_State_manager<_Ty>& _Get_state() {return _State;}_State_manager<_Ty>& _Get_state_for_set() {if (!_State.valid()) {_Throw_future_error(make_error_code(future_errc::no_state));}return _State;}_State_manager<_Ty>& _Get_state_for_future() {if (!_State.valid()) {_Throw_future_error(make_error_code(future_errc::no_state));}if (_Future_retrieved) {_Throw_future_error(make_error_code(future_errc::future_already_retrieved));}_Future_retrieved = true;return _State;}bool _Is_valid() const noexcept {return _State.valid();}bool _Is_ready() const {return _State._Is_ready();}bool _Is_ready_at_thread_exit() const {return _State._Is_ready_at_thread_exit();}_Promise(const _Promise&) = delete;_Promise& operator=(const _Promise&) = delete;private:_State_manager<_Ty> _State;bool _Future_retrieved;
   };
   

   注意：_Promise 和 std::promise 并不是同一个模板类，_Promise是为了提供对 std::promise 的进一步定制，并不是std::primse本身。std::primise模板类的私有成员是通过_Promise声明的，即

   // std::primise 的私有成员
   private:_Promise<_Ty*> _MyPromise;
   

   ---

   _Promise 类模板是对_State_manager类模板的包装，并增加了一个表示状态的私有成员 _Future_retrieved。

   private:_State_manager<_Ty> _State;bool _Future_retrieved;
   

   状态成员用于跟踪 _Promise 是否已经调用过 _Get_state_for_future() 成员函数；它默认为 false，在第一次调用 _Get_state_for_future() 成员函数时被置为 true，如果二次调用，就会抛出future_errc::future_already_retrieved异常。

   _Promise 的构造函数接受的不是_State_manager 类型的对象，而是_Associated_state 类型的指针，用来初始化数据成员 _State。

   _Promise(_Associated_state<_Ty>* _State_ptr) : _State(_State_ptr, false), _Future_retrieved(false) {}
   

   这是因为实际上_State_manager类型只有两个私有成员：Associated_state指针，以及一个状态成员：

   private:_Associated_state<_Ty>* _Assoc_state;bool _Get_only_once;
   

   可以简单理解为 _State_manager 是对 Associated_state 的包装，其中的大部分接口实际上是调用 _Assoc_state 的成员函数（你们可以去_State_manager的实现源码中查阅，大部分接口其实都是通过调用_Assoc_state实现的）。

   所以在解析std::async源码之前，我们必须对Associated_state有一个清晰的了解：

   public:_Ty _Result;exception_ptr _Exception;mutex _Mtx;condition_variable _Cond;bool _Retrieved;int _Ready;bool _Ready_at_thread_exit;bool _Has_stored_result;bool _Running;
   

   这是Associated_state模板类主要的成员变量（我没有全部列上去，只列了主要的），其中，最为重要的三个变量是：异常指针、互斥量、条件变量。

   其实，_Associated_state 模板类负责管理异步任务的状态，包括结果的存储、异常的处理以及任务完成的通知。它是实现 std::future 和 std::promise 的核心组件之一，通过 _State_manager 和 _Promise 类模板对其进行封装和管理，提供更高级别的接口和功能。

   

   _Promise、_State_manager、_Associated_state 之间的包含关系如上述结构所示。

6. 初始化 _Promise 对象：

   _Promise<_Ptype> _Pr(_Get_associated_state<_Ret>(_Policy, _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(_STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...))
   );
   

   这是一个函数调用，将我们 std::async 的参数全部转发给它。

   1. 首先将参数 _Fnarg （可调用对象）和 _Args...（传入可调用对象的参数包） 通过 std::forward 转发给 _Fake_no_copy_callable_adapter。
   2. 然后，_Fake_no_copy_callable_adapter 创建一个可调用对象（函数适配器）。
   3. 接着，适配器和指定的启动策略被传递给 _Get_associated_state 函数，目的是获取与异步操作相关的状态。
   4. 最终，_Get_associated_state 返回一个与异步操作相关的状态，并将其传递给 _Pr，这将会返回一个 _Promise<_Ptype>，代表一个异步操作的结果。

   _Get_associated_state函数根据启动模式（_Policy，有三种）来决定创建的异步任务状态对象类型：

   template <class _Ret, class _Fty>
   _Associated_state<typename _P_arg_type<_Ret>::type>* _Get_associated_state(launch _Psync, _Fty&& _Fnarg) {// construct associated asynchronous state object for the launch typeswitch (_Psync) { // select launch typecase launch::deferred:return new _Deferred_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));case launch::async: // TRANSITION, fixed in vMajorNext, should create a new thread heredefault:return new _Task_async_state<_Ret>(_STD forward<_Fty>(_Fnarg));}
   }
   

   _Get_associated_state 函数返回一个 _Associated_state 指针（ _Associated_state 可用于初始化_State_manager，_State_manager可用于初始化_Promise），该指针指向一个新的 _Deferred_async_state 或_Task_async_state 对象。这两个类分别对应于异步任务的两种不同执行策略：延迟执行和异步执行。

   这段代码也很好的说明，launch::async | launch::deferred 和 launch::async 的行为是相同的，都会创建新线程异步执行任务，只不过前者会自行判断系统资源来抉择。

   ---

   _Task_async_state 与 _Deferred_async_state 都继承自 _Packaged_state，其用于异步执行任务。它们的构造函数都接受一个函数对象，并将其转发给基类 _Packaged_state 的构造函数。

   // _Task_async_state 的构造函数
   template <class _Rx>
   class _Task_async_state : public _Packaged_state<_Rx()>
   // _Deferred_async_state 的构造函数
   template <class _Rx>
   class _Deferred_async_state : public _Packaged_state<_Rx()>
   

   _Packaged_state 类型只有一个数据成员 ：std::function 类型的对象 _Fn，它用来存储需要执行的异步任务，而它又继承自 _Associated_state。

   template <class _Ret, class... _ArgTypes>
   class _Packaged_state<_Ret(_ArgTypes...)>: public _Associated_state<_Ret>
   

   

   如上图所示，_Task_async_state 与 _Deferred_async_state 都继承自 _Packaged_state， _Packaged_state中保存了传入给std::async的可调用对象。同时，_Packaged_state继承自_Associated_state，_Associated_state 是_Primise类中成员_State的最基本组成对象，基本所有的接口都是通过调用_Associated_state 的函数实现的。

   _Task_async_state 与 _Deferred_async_state 的构造函数如下：

   // _Task_async_state
   template <class _Fty2>
   _Task_async_state(_Fty2&& _Fnarg) : _Mybase(_STD forward<_Fty2>(_Fnarg)) {_Task = ::Concurrency::create_task([this]() { // do it nowthis->_Call_immediate();});this->_Running = true;
   }
   // _Deferred_async_state
   template <class _Fty2>
   _Deferred_async_state(const _Fty2& _Fnarg) : _Packaged_state<_Rx()>(_Fnarg) {}
   template <class _Fty2>
   _Deferred_async_state(_Fty2&& _Fnarg) : _Packaged_state<_Rx()>(_STD forward<_Fty2>(_Fnarg)) {}
   

   a. _Task_async_state

   _Task_async_state有一个数据成员_Task用于从线程池中获取线程，并执行可调用对象：

   private:::Concurrency::task<void> _Task;
   

   _Task_async_state 的实现使用了微软实现的并行模式库（PPL）。简而言之， launch::async 策略并不是单纯的创建线程让任务执行，而是使用了微软的 ::Concurrency::create_task ，它从线程池中获取线程并执行任务返回包装对象。

   this->_Call_immediate()是调用 _Task_async_state 的父类 _Packaged_state 的成员函数 _Call_immediate.

   _Packaged_state有三个版本，自然_Call_immediate也有三种版本，用于处理可调用对象返回类型的三种情况：

   // 返回普通类型
   // class _Packaged_state<void(_ArgTypes...)>
   void _Call_immediate(_ArgTypes... _Args) {_TRY_BEGIN// 调用函数对象并捕获异常 传递返回值this->_Set_value(_Fn(_STD forward<_ArgTypes>(_Args)...), false);_CATCH_ALL// 函数对象抛出异常就记录this->_Set_exception(_STD current_exception(), false);_CATCH_END
   }// 返回引用类型
   // class _Packaged_state<_Ret&(_ArgTypes...)>
   void _Call_immediate(_ArgTypes... _Args) {_TRY_BEGIN// 调用函数对象并捕获异常 传递返回值的地址this->_Set_value(_STD addressof(_Fn(_STD forward<_ArgTypes>(_Args)...)), false);_CATCH_ALL// 函数对象抛出异常就记录this->_Set_exception(_STD current_exception(), false);_CATCH_END
   }// 返回void类型
   // class _Packaged_state<void(_ArgTypes...)>
   void _Call_immediate(_ArgTypes... _Args) { _TRY_BEGIN// 调用函数对象并捕获异常 因为返回 void 不获取返回值 而是直接 _Set_value 传递一个 1_Fn(_STD forward<_ArgTypes>(_Args)...);this->_Set_value(1, false);_CATCH_ALL// 函数对象抛出异常就记录this->_Set_exception(_STD current_exception(), false);_CATCH_END
   }
   

   _Fn(_STD forward<_ArgTypes>(_Args)...表示执行可调用对象，this->_Set_value(_Fn(_STD forward<_ArgTypes>(_Args)...)表示将可调用对象的返回值传入给_Set_value，其他两个函数也是类似的处理过程。

   _TRY_BEGIN、_CATCH_ALL、_CATCH_END类似try-catch块。当 _Fn 函数对象抛出异常时，控制流会跳转到 _CATCH_ALL 代码块；this->_Set_exception用来记录当前捕获的异常;_CATCH_END 标识异常处理的结束；因为返回类型为void 表示不获取返回值，所以这里通过_Set_value 传递一个 1（表示正确执行的状态）。所有的返回值均传入给_Set_value 。

   简而言之，就是把返回引用类型的可调用对象返回值的引用获取地址传递给 _Set_value，把返回 void 类型的可调用对象传递一个 1 （表示正确执行的状态）给 _Set_value。

   _Set_value、_set_exception函数来自_Packaged_state模板类的父类_Associated_state，通过这两个函数，传递的可调用对象执行结果，以及可能的异常，并将结果或异常存储在 _Associated_state 中。

   b. _Deferred_async_state

   _Deferred_async_state 并不会从线程池中获取一个新线程，然后再新线程中执行任务，而是当前线程调用future的get或者wait函数时，在当前线程中同步执行。但它同样调用 _Call_immediate 函数执行存储的可调用对象，它有一个 _Run_deferred_function 函数：

   void _Run_deferred_function(unique_lock<mutex>& _Lock) override { // run the deferred function_Lock.unlock();_Packaged_state<_Rx()>::_Call_immediate();_Lock.lock();
   }
   

   然后通过 _Call_immediate调用可调用对象并通过函数_Set_value、_set_exception存储可调用对象返回结果或者异常至_Associated_state。

7. 返回 std::future

   return future<_Ret>(_Pr._Get_state_for_future(), _Nil());
   

   _Ret在前面说了，其实就是可调用对象返回值的类型。

   传给future构造函数的参数之一是：_Pr._Get_state_for_future()，调用上面构造的_Promise的成员函数_Get_state_for_future，该函数用于返回_Promise类的私有成员变量_State。

   _Get_state_for_future函数的实现如下：

   _State_manager<_Ty>& _Get_state_for_future() {if (!_State.valid()) {_Throw_future_error2(future_errc::no_state);}if (_Future_retrieved) {_Throw_future_error2(future_errc::future_already_retrieved);}_Future_retrieved = true;return _State;
   }
   

   其实就是调用_State的成员函数valid()检查状态（是否有错），然后判断future是否提前返回可调用对象的返回值（如果是，代表future的get被调用，抛出异常）；最后，返回_State。

2. std::future

我们首先从一个最简单的std::async示例开始：

std::future<int> future = std::async([] { return 0; });
future.get();

我们从之前的学习中了解到，future.get()就是从future中获取可调用对象的返回结果。唯一的问题是：future.get() 内部执行了什么流程？首先从future的实现开始：

_EXPORT_STD template <class _Ty>
class future : public _State_manager<_Ty> {// class that defines a non-copyable asynchronous return object that holds a value
private:using _Mybase = _State_manager<_Ty>;public:static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,"T in future<T> must meet the Cpp17Destructible requirements (N4950 [futures.unique.future]/4).");future() = default;future(future&& _Other) noexcept : _Mybase(_STD move(_Other), true) {}future& operator=(future&&) = default;future(_From_raw_state_tag, const _Mybase& _State) noexcept : _Mybase(_State, true) {}_Ty get() {// block until ready then return the stored result or throw the stored exceptionfuture _Local{_STD move(*this)};return _STD move(_Local._Get_value());}_NODISCARD shared_future<_Ty> share() noexcept {return shared_future<_Ty>(_STD move(*this));}future(const future&)            = delete;future& operator=(const future&) = delete;
};

future类继承自_State_manager类，_State_manager类又有一个_Associated_state<_Ty>*类型的私有成员_State，而_State_manager的接口实现大部分是通过调用_Associated_state 的成员函数实现的。关系如下：

2.1 wait()

但你可能发现一个问题，future类怎么没有wait()成员函数？？？？其实，wait()函数继承自父类_State_manager。

void wait() const { // wait for signalif (!valid()) {_Throw_future_error2(future_errc::no_state);}_Assoc_state->_Wait();
}

而_State_manager类的wait()其实是通过调用_Associated_state的接口实现的，所以说，_Associated_state在std::async和std::future中是非常核心的。

virtual void _Wait() { // wait for signalunique_lock<mutex> _Lock(_Mtx);_Maybe_run_deferred_function(_Lock);while (!_Ready) {_Cond.wait(_Lock);}
}

_Associated_state的wait()函数通过unique_lock保护共享数据，然后调用_Maybe_run_deferred_function执行可调用对象，直至调用结束。

void _Maybe_run_deferred_function(unique_lock<mutex>& _Lock) { // run a deferred function if not already doneif (!_Running) { // run the function_Running = true;_Run_deferred_function(_Lock);}
}

_Maybe_run_deferred_function其实就是通过调用_Run_deferred_function来调用_Call_immediate()，我们在async源码中学习过_Run_deferred_function和`_Call_immediate()。

void _Run_deferred_function(unique_lock<mutex>& _Lock) override { // run the deferred function_Lock.unlock();_Packaged_state<_Rx()>::_Call_immediate();_Lock.lock();
}

在 _Wait 函数中调用 _Maybe_run_deferred_function 是为了确保延迟执行（launch::deferred）的任务能够在等待前被启动并执行完毕。这样，在调用 wait 时可以正确地等待任务完成。

因为只有std::launch::deferred才是当调用future.get或者wait时才会执行_Call_immediate()，其他两种启动策略在大部分情况下都是直接执行，通过future.get获得结果。所以我们必须保证在调用wait函数时，执行std::launch::deferred策略的任务被执行，而其他两种启动策略早已经执行任务，无需再调用_Call_immediate()。所以在_Maybe_run_deferred_function函数中，有下面一段，判断任务是否以及执行，如果被执行，那么久就不调用_Call_immediate，反之调用。

    if (!_Running) { // run the function_Running = true;_Run_deferred_function(_Lock);

---

   while (!_Ready) {_Cond.wait(_Lock);}

通过条件变量挂起当前线程，等待可调用对象执行完毕。在等待期间，当前线程释放持有的锁，保证其他线程再次期间可以访问到共享资源，待当前线程被唤醒后，重新持有锁。其主要作用是：

1. 避免虚假唤醒：
   • 条件变量的 wait 函数在被唤醒后，会重新检查条件（即 _Ready 是否为 true），确保只有在条件满足时才会继续执行。这防止了由于虚假唤醒导致的错误行为。
2. 等待 launch::async 的任务在其它线程执行完毕：
   • 对于 launch::async 模式的任务，这段代码确保当前线程会等待任务在另一个线程中执行完毕，并接收到任务完成的信号。只有当任务完成并设置 _Ready 为 true 后，条件变量才会被通知，从而结束等待。

这样，当调用 wait 函数时，可以保证无论任务是 launch::deferred 还是 launch::async 模式，当前线程都会正确地等待任务的完成信号，然后继续执行。

---

std::future 其实还有两种特化，不过整体大差不差。

template <class _Ty>
class future<_Ty&> : public _State_manager<_Ty*>

template <>
class future<void> : public _State_manager<int>

也就是对返回类型为引用和 void 的情况了。其实先前已经聊过很多次了，无非就是内部的返回引用实际按指针操作，返回 void，那么也得给个 1，表示正常运行的状态。类似于前面 _Call_immediate 的实现。

2.2 get()

get()函数是future的成员函数，而没有继承父类_State_manager：

// std::future<void>
void get() {// block until ready then return or throw the stored exceptionfuture _Local{_STD move(*this)};_Local._Get_value();
}
// std::future<T>
_Ty get() {// block until ready then return the stored result or throw the stored exceptionfuture _Local{_STD move(*this)};return _STD move(_Local._Get_value());
}
// std::future<T&>
_Ty& get() {// block until ready then return the stored result or throw the stored exceptionfuture _Local{_STD move(*this)};return *_Local._Get_value();
}

因为future有三种特化，所以get()函数也有三种特化。它们将当前future对象的指针通过std::move转移给类型为future的局部变量_Local（转移后，原本的future对象便失去了所有权）。然后，局部变量_Local调用成员函数_Get_value()，并将结果返回。

注意：局部对象 _Local 在函数结束时析构。这意味着当前对象（*this）失去共享状态，并且状态被完全销毁。

_Get_value() 函数的实现如下：

_Ty& _Get_value() const {if (!valid()) {_Throw_future_error2(future_errc::no_state);}return _Assoc_state->_Get_value(_Get_only_once);
}

future.valid() 成员函数检查 future 当前是否关联共享状态，即是否当前关联任务。如果还未关联，或者任务已经执行完（调用了 get()、set()），都会返回 false。

• 首先，通过valid()判断当前future对象是否关联共享状态，如果没，抛出异常。
• 最后，调用 _Assoc_state 的成员函数 _Get_value ，传递 _Get_only_once 参数，其实就是代表这个成员函数只能调用一次。

_Assoc_state 的类型是 _Associated_state<_Ty>* ，是一个指针类型，它实际会指向自己的子类对象，我们在讲 std::async 源码的时候提到了，它必然指向 _Deferred_async_state 或者 _Task_async_state。

_Assoc_state->_Get_value 这其实是个多态调用，父类有这个虚函数：

virtual _Ty& _Get_value(bool _Get_only_once) {unique_lock<mutex> _Lock(_Mtx);if (_Get_only_once && _Retrieved) {_Throw_future_error2(future_errc::future_already_retrieved);}if (_Exception) {_STD rethrow_exception(_Exception);}// TRANSITION: `_Retrieved` should be assigned before `_Exception` is thrown so that a `future::get`// that throws a stored exception invalidates the future (N4950 [futures.unique.future]/17)_Retrieved = true;_Maybe_run_deferred_function(_Lock);while (!_Ready) {_Cond.wait(_Lock);}if (_Exception) {_STD rethrow_exception(_Exception);}if constexpr (is_default_constructible_v<_Ty>) {return _Result;} else {return _Result._Held_value;}
}

子类 _Task_async_state 对其进行了重写，以 launch::async 策略或者std::launch::async | std::launch::deferred策略创建的future，实际会调用 _Task_async_state::_Get_value ：

_State_type& _Get_value(bool _Get_only_once) override {// return the stored result or throw stored exception_Task.wait();return _Mybase::_Get_value(_Get_only_once);
}

_Deferred_async_state 没有对其进行重写，直接调用父类虚函数。

_Task 就是 ::Concurrency::task<void> _Task;，调用 wait() 成员函数确保任务执行完毕。

_Mybase::_Get_value(_Get_only_once) 其实又是回去调用父类的虚函数了。

_Get_value 方法详解

1. _Get_value()只能调用一次

   如果 _Get_only_once 为 true 且 _Retrieved 为 true（表示结果已经被检索过），则抛出 future_already_retrieved 错误。

2. 处理异常

   如果在获取结果过程中出现了异常，需要重新抛出该异常

3. 设置 _Retrieved 为 true

   在获取值之前，设置 _Retrieved 为 true，表示结果已经被检索过。这样可以确保 future 对象不会被重复获取，避免多次调用 get 时引发错误。

4. 执行延迟函数

   调用_Maybe_run_deferred_function来运行可能的延迟任务。在该函数内部，如果任务已经运行，那么退出，如果没运行，调用_Call_immediate()函数执行可调用对象。

5. 等待结果

   使用条件变量挂起当前线程，确保线程同步，即只有当异步任务准备好返回结果时，线程才会继续执行。

6. 再次检查异常

   线程被唤醒将结果存储至future对象中后，再次判断是否发生了异常，需要重新抛出异常

7. 返回结果

   这部分代码根据 _Ty 类型的特性决定如何返回结果：

   • 如果 _Ty 类型是 默认可构造（即 _Ty 的默认构造函数有效），直接返回 _Result。
   • 否则，返回 _Result._Held_value

   is_default_constructible_v<_Ty> 是一个 C++17 引入的类型特征，用于检查类型 _Ty 是否具有默认构造函数。

   _Result 是 future 中持有的结果，而 _Held_value 是存储在 _Result 中的实际值。

_Result 是通过执行 _Call_immediate 函数，然后 _Call_immediate 再执行 _Set_value ，_Set_value 再执行 _Set_value_raw，_Set_value_raw再执行_Emplace_result并通知线程可以醒来，_Emplace_result 获取到我们执行任务的返回值的。以 Ty 的偏特化为例：

// _Packaged_state
void _Call_immediate(_ArgTypes... _Args) {_TRY_BEGIN// 调用函数对象并捕获异常 传递返回值this->_Set_value(_Fn(_STD forward<_ArgTypes>(_Args)...), false);_CATCH_ALL// 函数对象抛出异常就记录this->_Set_exception(_STD current_exception(), false);_CATCH_END
}// _Asscoiated_state
void _Set_value(const _Ty& _Val, bool _At_thread_exit) { // store a resultunique_lock<mutex> _Lock(_Mtx);_Set_value_raw(_Val, &_Lock, _At_thread_exit);
}
void _Set_value_raw(const _Ty& _Val, unique_lock<mutex>* _Lock, bool _At_thread_exit) {// store a result while inside a locked blockif (_Already_has_stored_result()) {_Throw_future_error2(future_errc::promise_already_satisfied);}_Emplace_result(_Val);_Do_notify(_Lock, _At_thread_exit);
}
template <class _Ty2>
void _Emplace_result(_Ty2&& _Val) {// TRANSITION, incorrectly assigns _Result when _Ty is default constructibleif constexpr (is_default_constructible_v<_Ty>) {_Result = _STD forward<_Ty2>(_Val); // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!} else {::new (static_cast<void*>(_STD addressof(_Result._Held_value))) _Ty(_STD forward<_Ty2>(_Val));_Has_stored_result = true;}
}