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;
}
