C++11提供了以下异步操作相关的类

• std::future : 作为异步结果的传输通道，可以很方便的获取线程函数的返回值
• std::promise: 用来包装一个值，将数据与future绑定起来
• std::package_task: 包装一个调用对象，将函数和future绑定起来，方便异步调用

线程异步操作函数std::async

在介绍上面的类之前，先来介绍下线程异步操作函数。
这是一个比std::promise、std::packaged_task和std::thread更高层次的操作,使得我们不用关注线程创建的细节。其返回结果为future。
创建有两种策略：

• std::launch::async: 在调用async时创建线程
• std::launch::deferred:延迟加载方式创建线程。调用时不创建线程，直到调用了future的get或者wait时才创建线程。

获取线程函数返回值的类std::future

一个异步操作的结果不能马上获取，只能在未来的某个地方获取，这个异步操作的结果是一个未来的期待值，因此称为future。我们可以通过同步等待的方式来获取结果，可以通过查询future的状态来获取异步操作的结果。

future_status有以下三种状态。

• deferred ： 异步操作还没开始
• ready：异步操作已经完成
• timeout： 异步操作超时

future有三种基本操作：

• get:获取返回结果值
• wait: 只等待异步操作完成
• wait_for : 超时等待返回结果

#include<iostream>
#include<thread> 
#include<future>
#include<chrono>

int main() {

    std::future<int> future = std::async(std::launch::async, [](){ 
        std::this_thread::sleep_for(std::chrono::seconds(1));
        return 8;  
    }); 
    std::future_status status;
    do {
        status = future.wait_for(std::chrono::seconds(2));//等待2秒后返回结果 
        switch(status) {
            case std::future_status::deferred:
                std::cout << "deferred" << std::endl;
            break;
            case std::future_status::ready:
                std::cout << "ready" << std::endl;
            break;
            case std::future_status::timeout:
                std::cout << "timeout" << std::endl;
            break;
            default:
                break;
         }
     } while(status != std::future_status::ready);
     
    std::cout << "result is " << future.get() << '\n';
}

协助线程赋值的类std::promise

std::promise为外面传进来的promise赋值，在函数执行完成后通过promise的future获取该值。

#include<iostream>
#include<thread> 
#include<future>
#include<chrono>

int main() {

    std::promise<int> pr;
    std::thread t([](std::promise<int>& p){
        p.set_value(1);

//      p.set_value_at_thread_exit(9);
    }, std::ref(pr));
    std::future<int> f = pr.get_future();
    auto r = f.get();
    std::cout << r << std::endl; 
    t.join();
}

可调用对象的包装类std::package_task

与std::promise类似，只是std::promise包装的是参数，而std::package_task包装的是方法

#include<iostream>
#include<thread> 
#include<future>
#include<chrono>

int main() {

    std::packaged_task<int()> task([]{return 2;});
    std::thread t(std::ref(task));
    std::future<int> f = task.get_future();
    auto r = f.get();
    std::cout << r << std::endl; 
    t.join();
}

总结起来，std::promise、std::packaged_task和std::future的关系如下

• 当需要异步操作中的某个值时，可以用std::promise
• 当需要异步操作的返回值时，可以用std::packaged_task(当然，这也可以用std::promise实现）
• std::future是std::promise和std::pakaged_task的数据通道

shared_futured

• future不可拷贝，只能移动。但shared_future可以拷贝。当需要将future放进容器中时，用shared_future
  shared_future的基本用法

#include<iostream>
#include<thread> 
#include<future>
#include<utility>
#include<vector>

int f(int x) {
    return x + 1;
}
int main() {
    std::packaged_task<int(int)> task(f);
    std::future<int> fut = task.get_future();   
    std::thread(std::move(task),2).detach();

    //future不能复制，不能放到容器中
    std::vector<std::shared_future<int>> v;
    std::shared_future<int> f = std::async(std::launch::async, [](int a, int b){return a + b;}, 2, 3);
    v.push_back(f);
//  v.push_back(fut);//error
    std::cout << "The shared_future result is" << v[0].get() << std::endl; 
}