C++并发编程之future

不同于pthread_join可以获取线程函数的返回值，std::thread的join函数并不能获取线程函数的返回值。C++11给出的解决方案是使用std::promise和std::future.

std::future

std::future提供了一种访问异步操作结果的机制，但是我们也可以以同步等待的方式来获取结果，可以通过查询future的状态（future_status）来获取异步操作的结果。

//查询future的状态
std::future_status status;
    do {
        status = future.wait_for(std::chrono::seconds(1));
        if (status == std::future_status::deferred) {
            std::cout << "deferred\n";
        } else if (status == std::future_status::timeout) {
            std::cout << "timeout\n";
        } else if (status == std::future_status::ready) {
            std::cout << "ready!\n";
        }
    } 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();

如果线程函数在调用set_value_at_thread_exit()之前就抛异常或者return了, 线程在析构时，发现还没对std::pormise变量进行设置，那么析构函数就会为其关联的std::future存储一个std::future_error异常。此时，std::future的get()函数会抛出一个std::futre_error异常。因此需要保证promise变量的生命周期要小于线程，上述代码即是一个反例，正确的代码如下:

	std::promise<int> pr;
    std::thread t([](std::promise<int> p){ p.set_value_at_thread_exit(9); },std::move(pr));
    std::future<int> f = pr.get_future();
    auto r = f.get();

值得注意的是：std::future是一次性的。std::promise只能调用一次get_future，std::future也只能调用一次get()。 如果想在多个线程中共享一个std::promise的设置值，可以使用std::shared_future.

std::packaged_task

std::packaged_task包装了一个可调用的目标（如function, lambda expression, bind expression, or another function object）,以便异步调用，它和promise在某种程度上有点像，promise保存了一个共享状态的值，而packaged_task保存的是一个函数。它的基本用法：

 	std::packaged_task<int()> task([](){ return 7; });
    std::thread t1(std::ref(task)); 
    std::future<int> f1 = task.get_future(); 
    auto r1 = f1.get();

std::async

虽然有了std::packaged_task后，获取线程函数的返回值会简洁许多。但异步计算平均值还需要定义一个std::packaged_task和std::thread变量，增加了些许复杂度。能否在std::packaged_task和std::thread的基础上再进行一次封装，使得使用时更加简洁。当然是有的，std::async就是完成这样工作的。std::async无需考虑线程创建和线程间如何传值这些底层的问题，使用者只需专注于编写异步函数并返回适当的结果即可。

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

double calcAvg(const std::vector<int> &vec)
{
    double sum = std::accumulate(vec.begin(), vec.end(), 0.0);
    double avg = 0;
    if (!vec.empty())
        avg = sum / vec.size();

    return avg;
}

int main()
{
    std::vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    std::future<double> fu = std::async(std::launch::async, calcAvg, std::ref(vec));

    double avg = fu.get();
    std::cout << "avg = " << avg << std::endl;

    return 0;
}

现在来看看std::async的原型：

async(std::launch::async | std::launch::deferred, f, args...)

第一个参数是线程的创建策略，有三种策略：

• std::launch::async：在调用async就开始创建线程。
• std::launch::deferred：延迟加载方式创建线程。调用async时不创建线程，直到调用了future的get或者wait时才创建线程。
• std::launch::async | std::launch::deferred： 默认行为。它可以异步运行或不运行，这取决于系统的负载，但我们无法控制它。