1. future

c++库使用future等待一次性事件，并且有两类，一类是仅有一个std::future实例指向其关联的事件;另一类是有多个std::shared_futrue实例指向同一事件（多线程并发使用shared_futrue指向同一事件）
future用于异步任务获取值，一般与async和promise一起使用

2. async

async用于启动一个异步任务，并返回一个std::future对象，future持有最终的返回值，可通过future的get()方法阻塞等待获取。

#include <iostream>
#include <future>struct Y
{double operator()(double in){return in;}
};
Y y;int factorial(int N) {int res = 1;for (int i = N; i > 1; i--)res *= i;std::cout << "Result is: " << res << std::endl;return res;
}struct X
{void foo(int, std::string const &){}std::string bar(std::string const & in){return in;}
};X x;int main() {std::future<double> f = std::async(Y(), 3.141);std::future<double> f1 = std::async(std::ref(y), 3.141);std::future<double> f2 = std::async(std::launch::async, std::ref(y), 3.141);std::future<double> f3 = std::async(std::launch::deferred, std::ref(y), 3.141);auto f4 = std::async(&X::foo, &x, 43, "hello");auto f5 = std::async(&X::bar, x, "goodbye");std::future<int> f6 = std::async(factorial, 4);std::cout<< f.get()<<std::endl;std::cout<< f1.get()<<std::endl;std::cout<< f2.get()<<std::endl;std::cout<< f3.get()<<std::endl;std::cout<< f6.get()<<std::endl;return 0;
}

std::async允许通过将额外的参数添加到调用中，来将附加参数传递给函数，这与std::thread是同样的方式。

• 第一个参数指向成员函数指针，第二个参数则提供了用来应用该成员函数的对象（对象，指针，或者通过std::ref封装），其余的参数作为参数传递给该成员函数
• 第二个参数作为参数传递给第一个参数所指定的函数或可调用对象
• 如果参数是右值，则通过移动原来的参数来创建副本。

async有两种执行方式，通过第一个参数传入

• std::launch::async 立即执行
• std::launch::deferred 延迟执行，直到在future上调用wait()或者get()
• std::launch::deferred | std::launch::async 也是默认方式，创建对象时是否创建新线程，这取决于implementation

3. promise

这个对象能够将信息从父线程传到子线程

• 父线程首先创建一个promise对象，表示后续会使用它传递信息给子线程。

• 之后使用promise对象创建future对象，作为实际的父子线程间传递信息的桥梁。

• 然后使用async函数创建新的future对象，被调用函数需要使用promise创建的对象引用作为参数。

• 被调用函数内使用future.get()方法，会在此等待父线程的信息。

• 父线程后续执行完其他任务后，会使用promise.set_value(val)方法，将参数传给future，也就传给了子线程。

• 子线程收到参数后，继续执行，最后返回值给父线程。

int factorial(std::future<int>& f) {int res = 1;int N = f.get();for (int i = N; i > 1; i--)res *= i;cout << "Result is: " << res << endl;return res;
}int main() {int x;std::promise<int> p;std::future<int> f = p.get_future();std::future<int> fu = std::async(std::launch::async, factorial, std::ref(f));// do something else// ...p.set_value(4);	x = fu.get();cout << "Get from child: " << x << endl;return 0;
}

promise处了可以调用set_value外还可以调用set_exception，并将值保存在future中返回，常用用于异常处理返回值。

try{some_promise.set_value(alculate_value());
}
catch(...)
{some_promise.set_exception(std::current_exception())
}

注意，promise和future都只能被move，不能被copy。

4. shared_future

shared_future能够被copy，因此不用必须传引用。这样，就可以使用一个shared_future对象，供多个线程使用。

int factorial2(std::shared_future<int> f) {int res = 1;int N = f.get();for (int i = N; i > 1; i--)res *= i;cout << "Result is: " << res << endl;return res;
}int main() {int x;std::promise<int> p;std::future<int> f = p.get_future();std::shared_future<int> sf = f.share();std::future<int> fu1 = std::async(factorial2, sf);std::future<int> fu2 = std::async(factorial2, sf);std::future<int> fu3 = std::async(factorial2, sf);// ... 10 threadsp.set_value(4);cout<< fu1.get() + fu2.get() + fu3.get() << endl;return 0;
}