（40）用 thread 类 或全局 async (…) 函数，创建新线程时，谁才是在新线程里第一个被执行的函数？
弄清楚这个问题，有利于推测和理解线程中代码的执行流程。根据 thread 类 和 async （…）函数的源码实现，得到的结论是：各个线程拥有独立的栈空间来执行函数，存储函数的局部变量。但各个线程共用进程的堆空间。所以通过指向堆区的指针，各个线程之间可以实现数据的传递与共享。其实在堆区保存的是 tuple 元组，该 tuple 可以保存各种类型的数据：函数与其参数。新线程中启动的 c++ 全局函数 invoke（…） 会解析该 tuple 元组，并调用里面的函数。从而把咱们程序员指定的函数在新线程中运行起来。下面根据源代码举例说明。
（41） thread 类的创建新线程流程：
++ 以下也给出其源码版：
template <class _Fn, class... _Args, enable_if_t<!is_same_v<_Remove_cvref_t<_Fn>, thread>, int> = 0>
thread(_Fn&& _Fx, _Args&&... _Ax) { _Start( forward<_Fn>(_Fx), forward<_Args>(_Ax)...); }template <class _Fn, class... _Args> void _Start(_Fn&& _Fx, _Args&&... _Ax)
{using _Tuple = tuple<decay_t<_Fn>, decay_t<_Args>...>;auto _Decay_copied = make_unique<_Tuple>(forward<_Fn>(_Fx), forward<_Args>(_Ax)...);auto _Invoker_proc = _Get_invoke<_Tuple>(make_index_sequence<1 + sizeof...(_Args)>{});// u_long _beginthreadex( void* security, u_long stack_size, u_long (* start_address)(void*), _Thr._Hnd = reinterpret_cast<void*>( //void* arglist, u_long initflag, u_long* thrdaddr ); _CSTD _beginthreadex(nullptr, 0, _Invoker_proc, _Decay_copied.get(), 0, &_Thr._Id));
}template <class _Tuple, size_t... _Indices> // 本函仅仅是返回上面的函数的地址
static auto _Get_invoke(index_sequence<_Indices...>) { return &_Invoke<_Tuple, _Indices...>; }template <class _Tuple, size_t... _Indices> static unsigned int _Invoke(void* _RawVals)
{ // 先把形参的 void* 指针转换为有意义的指针类型unique_ptr<_Tuple> _FnVals(static_cast<_Tuple*>(_RawVals)); _Tuple& _Tup = *_FnVals;_STD invoke(_STD move(_STD get<_Indices>(_Tup))...); return 0;
}（42）创建新线程，还有另一种方式，就是使用 async（…）函数。这种方式，创建新线程，又是哪一个函数最先被执行呢：
++ 这里再给出代码版本：
template <class _Ret, class... _ArgTypes>
class _Packaged_state<_Ret& (_ArgTypes...)> : public _Associated_state<_Ret*> {
private: function<_Ret& (_ArgTypes...)> _Fn; // 包含了一个 function 对象以容纳各种可调用对象
public : template <class _Fty2> // 有参构造函数_Packaged_state(_Fty2&& _Fnarg) : _Fn(_STD forward<_Fty2>(_Fnarg)) {}void _Call_immediate(_ArgTypes... _Args) {this->_Set_value( addressof( _Fn( forward<_ArgTypes>(_Args)...) ), false);}
};template <class _Rx>
class _Task_async_state : public _Packaged_state< _Rx() > { // 此处指明了封装的函数类型 R()
private: ::Concurrency::task<void> _Task; // 这是要新建线程对象
public : using _Mybase = _Packaged_state<_Rx()>; // 简写父类，同时指出被调函数是无参函数template <class _Fty2> // 有参构造函数_Task_async_state(_Fty2&& _Fnarg) : _Mybase(_STD forward<_Fty2>(_Fnarg)) { _Task = ::Concurrency::create_task( [this]() { this->_Call_immediate(); } );}
};//*************************************************************************************************template <class _Ret, class _Fty>
_Associated_state<typename _P_arg_type<_Ret>::type>* // 返回值
_Get_associated_state(launch _Psync, _Fty&& _Fnarg) {switch (_Psync) {case launch::async: default : return new _Task_async_state<_Ret>(_STD forward<_Fty>(_Fnarg)); }
} // 模板参数 _Fty 就是 _Fake_no_copy_callable_adapter<T...> 类型,包含被调函数及其实参的 tuple 元组template <class _Fty, class... _ArgTypes>
future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> // 函数返回值
async(launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args)
{ // 简写函数的返回值类型，并对函数的返回值的类型进行必要的转换。using _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...>( forward<_Fty>(_Fnarg), forward<_ArgTypes>(_Args)...)));return future<_Ret>(_Pr._Get_state_for_future(), _Nil());
} // 调用了 future 的某版本的构造函数//**************************************************************************************************************template <class... _Types> // 本类型是一个可调用对象
class _Fake_no_copy_callable_adapter //核心是包括了一个 tuple 元组
{
public: using _Storaget = tuple<decay_t<_Types>...>; mutable _Storaget _Storage;_Fake_no_copy_callable_adapter(_Types&&... _Vals) : _Storage( forward<_Types>(_Vals)...) {}auto operator()() -> decltype(_Invoke_stored( move( declval<_Storaget&>()) ) ){ return _Invoke_stored(_STD move(_Storage)); }
};template <class... _Types>
auto _Invoke_stored(tuple<_Types...>&& _Tuple) // invoke() a tuple
-> decltype(_Invoke_stored_explicit(_STD move(_Tuple), index_sequence_for<_Types...>{}))
{ return _Invoke_stored_explicit(_STD move(_Tuple), index_sequence_for<_Types...>{}); }template <class... _Types, size_t... _Indices> // invoke() a tuple with explicit parameter ordering
auto _Invoke_stored_explicit(tuple<_Types...>&& _Tuple, index_sequence<_Indices...>)
-> decltype(_STD invoke(_STD get<_Indices>(_STD move(_Tuple))...))
{ return _STD invoke(_STD get<_Indices>(_STD move(_Tuple))...); }
（43）
谢谢