简介
C++11之前，主线程要想获取子线程的返回值，一般都是通过全局变量，或者类似机制。C++11开始为我们提供了一组方法来获取子线程的返回值，并保证其原子性。
头文件
#include <future>
std::promise
在promise中保存了一个值或者异常，可以通过与其关联的 std::future 来获取这个值或者异常。常规用法
promise有两个特化的版本
template< class R > class promise; // 普通类模板
template< class R > class promise<R&>; // 引用特化
template<> class promise<void>; // void特化
promise提供的方法
构造方法
promise(); // 默认构造方法
template< class Alloc >
promise( std::allocator_arg_t, const Alloc& alloc ); // cppreference上说是基于一个共享状态构造promise，还没有深入研究具体怎么用
promise( promise&& other ) noexcept; // 移动构造方法
promise( const promise& other ) = delete; // 删除了拷贝构造方法
析构方法
析构的时机有两个
- promise内部共享状态为ready时
- 如果promise的状态没有被设置为ready析构时，会将std::future_error异常保存到共享状态里
和构造方法类似，promise只支持移动赋值操作符
promise& operator=( promise&& other ) noexcept;
promise& operator=( const promise& rhs ) = delete;
获取future，如果get_future是被重复调用的，那么就会抛出std::future_error异常。如果想多个地方获取future，需要使用std::shared_future,他可以通过std::future构造。这是std::shared_future相应的构造方法的声明：shared_future( std::future&& other )
std::future<R> get_future();
设置共享数据，以及将共享状态设置为ready。由于promise有特化版本，下面声明的方法有些版本没有。另外，如果重复调用set_value会抛出std::future_error异常，即set_value只能调用一次。
void set_value( const R& value ); // member only of generic promise template
void set_value( R&& value ); //member only of generic promise template
void set_value( R& value ); // member only of promise<R&> template specialization
void set_value(); // 设置共享状态为ready
设置异常，以及将共享状态设置为ready，例子
void set_exception( std::exception_ptr p );
set_value_at_thread_exit 和 set_exception_at_thread_exit 类似set_value 和 set_exception，不同点是 xx_at_thread_exit 是在线程结束的时候将共享状态设置为ready，而set_xx 是立刻设置为ready。
std::future
future类是获取异步操作返回的封装。promise相当于是set，future相当于是get
类似promise，future也有两个特化版本
template< class T > class future;
template< class T > class future<T&>;
template<> class future<void>;
future提供的方法
构造方法
future() noexcept; // 不关联任何共享状态
future( future&& other ) // 移动构造
future( const future& other ) = delete; // 拷贝构造被删除
只有移动赋值操作符
future& operator=( future&& other ) noexcept;
future& operator=( const future& other ) = delete;
从构造方法和移动赋值操作符可以看出，future是唯一关联共享状态的，如果想多个future关联一个共享状态，future是不行的，需要将其转为std::shared_future。对应的方法是share：
std::shared_future<T> share() noexcept;
share方法内部是这么构造shared_future的：std::shared_future(std::move(*this))，所以调用share方法后，原理的future就不在关联共享状态了，也就不能再调用相关get方法，否则会抛出异常
std::shared_future
和std::future唯一的不同就是，std::shared_future可以多个对象同时关联同一个共享状态。他的特化版本、提供的方法和std::future也基本类似：
std::packaged_task
将可调用对象（函数，lambda表达式，仿函数等）包装后，可以异步调用，通过std::future获取返回值。参考代码
std::packaged_task 提供的方法
构造方法
packaged_task() noexcept;template< class F >
explicit packaged_task( F&& f ); // f为可调用对象，他是一个万能引用，即构造package_task的时候，可以传递给他可调用对象的左值，右值，左值引用，右值引用；参考：https://zhuanlan.zhihu.com/p/99524127template< class F, class Allocator >
explicit packaged_task( std::allocator_arg_t, const Allocator& a, F&& f ); // C++17删除了该方法packaged_task( const packaged_task& ) = delete;packaged_task( packaged_task&& rhs ) noexcept; // 移动构造方法
析构方法
如果在共享状态设置为ready之前析构package_task，会抛出 std::future_errc::broken_promise 异常
只有移动赋值操作符
packaged_task& operator=( const packaged_task& ) = delete;
packaged_task& operator=( packaged_task&& rhs ) noexcept;
判断package_task对象是否有共享状态，比如用无参的构造方法构造的对象，就没有共享状态
bool valid() const noexcept;
获取future，如果重复调用get_future，会抛出std::future_error异常；另外，如果valid()方法返回为false，调用get_future，也会抛出std::future_error异常
std::future<R> get_future();
执行保存的可调用对象，和get_future一样重复调用，或者pakage_task对象没有共享状态，都会抛出std::future_error异常
void operator()( ArgTypes... args );
在线程结束，局部变量释放后，将共享状态设置为ready。抛出异常的情况和operator()一样
void make_ready_at_thread_exit( ArgTypes... args );
重置package_task的共享状态，等价于 *this = packaged_task(std::move(f))， f 是可调用对象。此时会构造新的共享状态，如果没有足够内存，会抛出std::bad_alloc异常。如果package_task对象没有共享状态，就会抛出std::future_error异常
void reset();
std::async
异步直行一个可调用对象
enum class launch : /* unspecified */ {async = /* unspecified */, // 立刻异步直行deferred = /* unspecified */, // /* implementation-defined */
};
当使用launch::deferred时，只有future调用get或者wait方法时，才会异步直行可调用对象
