为什么C++11引入std::future和std::promise？C++11创建了线程以后，我们不能直接从thread.join()得到结果，必须定义一个变量，在线程执行时，对这个变量赋值，然后执行join()，过程相对繁琐。
thread库提供了future用来访问异步操作的结果。std::promise用来包装一个值将数据和future绑定起来，为获取线程函数中的某个值提供便利，取值是间接通过promise内部提供的future来获取的，也就是说promise的层次比future高。
#include "stdafx.h"
#include <iostream>
#include <type_traits>
#include <future>
#include <thread>
using namespace std;
int main()
{
std::promise<int> promiseParam;
std::thread t([](std::promise<int>& p)
{
std::this_thread::sleep_for(std::chrono::seconds(10));// 线程睡眠10s
p.set_value_at_thread_exit(4);//
}, std::ref(promiseParam));
std::future<int> futureParam = promiseParam.get_future();
auto r = futureParam.get();// 线程外阻塞等待
std::cout << r << std::endl;
return 0;
}
上述程序执行到futureParam.get()时，有两个线程，新开的线程正在睡眠10s，而主线程正在等待新开线程的退出值，这个操作是阻塞的，也就是说std::future和std::promise某种程度也可以做为线程同步来使用。
std::packaged_task包装一个可调用对象的包装类（如function，lambda表达式（C++11之lambda表达式），将函数与future绑定起来。std::packaged_task与std::promise都有get_future()接口，但是std::packaged_task包装的是一个异步操作，而std::promise包装的是一个值。
#include "stdafx.h"
#include <iostream>
#include <type_traits>
#include <future>
#include <thread>
using namespace std;
int main()
{
std::packaged_task<int()> task([]() {
std::this_thread::sleep_for(std::chrono::seconds(10));// 线程睡眠10s
return 4; });
std::thread t1(std::ref(task));
std::future<int> f1 = task.get_future();
auto r = f1.get();// 线程外阻塞等待
std::cout << r << std::endl;
return 0;
}
std::future
std::future是一个非常有用也很有意思的东西，简单说std::future提供了一种访问异步操作结果的机制。从字面意思来理解，它表示未来，我觉得这个名字非常贴切，因为一个异步操作我们是不可能马上就获取操作结果的，只能在未来某个时候获取，但是我们可以以同步等待的方式来获取结果，可以通过查询future的状态（future_status）来获取异步操作的结果。future_status有三种状态：
- deferred：异步操作还没开始
- ready：异步操作已经完成
- timeout：异步操作超时
//查询future的状态
std::future_status status;
do {
status = future.wait_for(std::chrono::seconds(1));
if (status == std::future_status::deferred) {
std::cout << "deferred
";
} else if (status == std::future_status::timeout) {
std::cout << "timeout
";
} else if (status == std::future_status::ready) {
std::cout << "ready!
";
}
} while (status != std::future_status::ready);
获取future结果有三种方式：get、wait、wait_for，其中get等待异步操作结束并返回结果，wait只是等待异步操作完成，没有返回值，wait_for是超时等待返回结果。
std::promise
std::promise为获取线程函数中的某个值提供便利，在线程函数中给外面传进来的promise赋值，当线程函数执行完成之后就可以通过promis获取该值了，值得注意的是取值是间接的通过promise内部提供的future来获取的。它的基本用法：
std::promise<int> pr;
std::thread t([](std::promise<int>& p){ p.set_value_at_thread_exit(9); },std::ref(pr));
std::future<int> f = pr.get_future();
auto r = f.get();
std::packaged_task
std::packaged_task它包装了一个可调用的目标（如function, lambda expression, bind expression, or another function object）,以便异步调用，它和promise在某种程度上有点像，promise保存了一个共享状态的值，而packaged_task保存的是一个函数。它的基本用法：
#include <chrono>
#include <functional>
int Test_Fun(int a, int b, int &c)
{
//a=1,b=2,c=0
//突出效果，休眠5s
std::this_thread::sleep_for(std::chrono::seconds(5));
//c=233
c = a + b + 230;
return c;
}
int main()
{
//声明一个std::packaged_task对象pt1，包装函数Test_Fun
std::packaged_task<int(int, int, int&)> pt1(Test_Fun);
//声明一个std::future对象fu1，包装Test_Fun的返回结果类型，并与pt1关联
std::future<int> fu1 = pt1.get_future();
//声明一个变量
int c = 0;
//创建一个线程t1，将pt1及对应的参数放到线程里面执行
std::thread t1(std::move(pt1), 1, 2, std::ref(c)); //这必须用转移,或std::ref(pt1)
t1.join();
//阻塞至线程t1结束(函数Test_Fun返回结果)
int iResult = fu1.get();
std::cout << "执行结果：" << iResult << std::endl; //执行结果：233
std::cout << "c：" << c << std::endl; //c：233
system("pause");
return 1;
}
而std::async比std::promise, std::packaged_task和std::thread更高一层，它可以直接用来创建异步的task，异步任务返回的结果也保存在future中。std::async的原型：
async( std::launch policy, Function&& f, Args&&... args );
std::launch policy有两个，一个是调用即创建线程（std::launch::async），一个是延迟加载方式创建线程（std::launch::deferred），当掉使用async时不创建线程，知道调用了future的get或者wait时才创建线程。之后是线程函数和线程参数。
#include "stdafx.h"
#include <iostream>
#include <future>
#include <thread>
int main()
{
// future from a packaged_task
std::packaged_task<int()> task([]() {
std::cout << "packaged_task started" << std::endl;
return 7; }); // wrap the function
std::future<int> f1 = task.get_future(); // get a future
std::thread(std::move(task)).detach(); // launch on a thread
// future from an async()
std::future<int> f2 = std::async(std::launch::deferred, []() {
std::cout << "Async task started" << std::endl;
return 8; });
// future from a promise
std::promise<int> p;
std::future<int> f3 = p.get_future();
std::thread([&p] { p.set_value_at_thread_exit(9); }).detach();
f1.wait();
f2.wait();
f3.wait();
std::cout << "Done!
Results are: "
<< f1.get() << ' ' << f2.get() << ' ' << f3.get() << '
';
}