std::future和std::async，std::packaged_task，std::promise的交互

std::future和std::async，std::packaged_task，std::promise的交互

std::future是C++标准库对一次性事件的表述，而std::async，std::packaged_task，std::promise是三种驱动异步任务的方式，三者各有方法返回一个对应的std::future，调用方可以使用它来获取返回值。

std::async（一般）会立即在另一个线程中执行任务，std::packaged_task会在主动调用operator()时在另一线程中执行任务，std::promise只作为通知方式，本身不能执行任务；见后面的例子。

get future

• std::async：返回值即std::future。
• std::packaged_task：调用get_future()方法获得std::future`。
• std::promise：调用get_future()方法获得std::future`。

set value

• std::async：即taskFunc返回值。
• std::packaged_task：即taskFunc返回值。
• std::promise：调用set_value()主动设置，只能调用一次。

set exception

• std::async：直接throw。
• std::packaged_task：直接throw。
• std::promise：调用set_exception(std::exception_ptr)主动设置。

get value or exception

一个与std::async，std::packaged_task，std::promise三者之一相关联的future对象是valid的。在std::async，std::packaged_task，std::promise set value之后，对应的future对象将变为ready状态。

• get()方法获取对应的关联值，调用后future变为invalid状态；如果任务抛出了异常，那么get()方法将重抛出此异常。

• valid()方法可以检查future对象是否处于关联状态，空构造和被移动的future对象将返回false。

• wait()方法阻塞等待future对象变为ready状态。

• wait_for()和wait_until()方法等待一段时间，返回值可表明发生了超时还是future对象已ready（或者此future对象被deferred）。

注意区分valid和ready两个状态，可调用get()方法的future处于valid状态，get()方法可以立即获取值的future处于ready状态。

例子：

#include <cassert>
#include <vector>
#include <iostream>
#include <climits>
#include <memory>
#include <algorithm>
#include <thread>
#include <mutex>
#include <cassert>
#include <unistd.h>
#include <future>
using namespace std;

// for async
int taskFunc()
{
    cout << "task start!" << endl;
    sleep(2);
    cout << "task end!" << endl;
    return 100;
}

// for packaged_task
int taskFuncWithException()
{
    cout << "task start!" << endl;
    sleep(2);
    cout << "task end!" << endl;
    throw runtime_error("error");
    return 0;
}

// for promise
void taskFuncPro(promise<int> pro)
{
    cout << "task start!" << endl;
    sleep(2);
    pro.set_exception(make_exception_ptr(runtime_error("error")));
    cout << "task end!" << endl;
    //pro.set_value(200);
}

int main()
{
    // 1. async
    auto fut1 = async(taskFuncWithException); // 如果没有defered，将在此时执行任务
    assert(fut1.valid());
    try
    {
        cout << "async ret: " << fut1.get() << endl;
    }
    catch (...)
    {
        cout << "caught!" << endl;
    }
    assert(!fut1.valid());

    // 2. packaged_task
    packaged_task<int()> task(taskFunc);
    auto fut2 = task.get_future();
    cout << "before call task" << endl;
    task(); // 此时执行任务
    assert(fut2.valid());
    cout << "packaged_task ret: " << fut2.get() << endl;
    assert(!fut2.valid());

    // 3. promise
    promise<int> pro;
    auto fut3 = pro.get_future();

    thread t(taskFuncPro, std::move(pro)); // 借助thread执行任务
    try
    {
        assert(fut3.valid());
        cout << "promise ret: " << fut3.get() << endl;
        assert(!fut3.valid());
    }
    catch (...)
    {
        cout << "caught!" << endl;
    }
    t.join();
}

future VS shared_future

上面提到的设施都是只移型别，而shared_future是可拷贝的，它用来在多个任务中共享等待同一事件发生。

future::share()将future对象装换为shared_future对象。

例子：

#include <cassert>
#include <vector>
#include <iostream>
#include <climits>
#include <memory>
#include <algorithm>
#include <thread>
#include <mutex>
#include <cassert>
#include <unistd.h>
#include <future>

using namespace std;

// for async
int taskFunc()
{
    return 100;
}

int main()
{
    // get shared_future
    auto fut1 = async(launch::deferred, taskFunc);
    shared_future<int> ready_future(std::move(fut1));
    assert(!fut1.valid());

    //
    auto task1 = [ready_future]()
    {
        cout << "in task1 " << ready_future.get() << endl;
    };

    auto task2 = [ready_future]()
    {
        cout << "in task2 " << ready_future.get() << endl;
    };

    async(launch::async, task1);
    async(launch::async, task2);
    sleep(2);
}