C++ 并发编程：std::promise/future、std::async、std:: packaged_task

1、std::promise 和 std::future
future 和 promise 的作用是在不同线程之间传递数据，而且支持泛型的操作，使用起来更加方便。

使用 future 和 promise 在线程之间获取数据的机制又是什么呢？

假设线程 1 需要线程 2 的数据，则：

线程 1 初始化一个 promise 对象和一个 future 对象，promise 传递给线程2，相当于线程 2 对线程 1 的一个承诺；future 相当于一个接受一个承诺，用来获取未来线程 2 传递的值；
线程 2 获取到 promise 后，需要对这个 promise 传递有关的数据，之后线程 1 的 future 就可以获取数据了。
如果线程 1 想要获取数据，而线程 2 未给出数据，则线程 1 阻塞，直到线程 2 的数据到达

#include <iostream>
#include <iomanip>
#include <string>
#include <random>
#include <any>
#include <functional>
#include <future>
#include <thread>
#include <chrono>
#include <cstdlib>

void SetPromise(std::promise<int>& promiseObj) {
    std::cout << "In a thread, making data...\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    promiseObj.set_value(10);
    std::cout << "Finished\n";
}

int main() {
    std::promise<int> promiseObj;
    std::future<int> futureObj = promiseObj.get_future();
    std::thread t(&SetPromise, std::ref(promiseObj));
    std::cout << futureObj.get() << std::endl;
    t.join();

    return 0;
}

2、std::async

async 可以理解为是 future 和 thread 的高级封装，基本上可以代替std::thread 的所有事情。 async用于创建异步任务，实际上就是创建一个线程执行相应任务。 任务创建之后，std::async 立即返回一个std::future 象。主线程既可使用 std::future::get 获取结果，如果调用过程中，任务尚未完成，则主线程阻塞直至任务完成。主线程也可使用 std::future::wait_for 等待结果返回，wait_for 可设置超时时间，如果在超时时间之内任务完成，则返回 std::future_status::ready 状态；如果在超时时间之内任务尚未完成，则返回std::future_status::timeout状态。

#include <iostream>
#include <future>
#include <thread>
#include <chrono>
using namespace std::chrono_literals;
 
int main()
{
    std::future<int> future = std::async(std::launch::async, [](){
        std::this_thread::sleep_for(3s);
        return 8;
    });
 
    std::cout << "waiting...\n";
    std::future_status status;
    do {
        switch(status = future.wait_for(1s); status) {
            case std::future_status::deferred: std::cout << "deferred\n"; break;
            case std::future_status::timeout: std::cout << "timeout\n"; break;
            case std::future_status::ready: std::cout << "ready!\n"; break;
        }
    } while (status != std::future_status::ready);
 
    std::cout << "result is " << future.get() << '\n';
}

3、std::packaged_task
packaged_task 的作用就是提供一个不同线程之间的数据同步机制，它可以存储一个函数操作，并将其返回值传递给对应的 future， 而这个 future 在另外一个线程中也可以安全地访问到这个值。

#include <iostream>
#include <cmath>
#include <thread>
#include <future>
#include <functional>
 
int f(int x, int y) { return std::pow(x,y); }
 
void task_lambda()
{
    std::packaged_task<int(int,int)> task([](int a, int b) {
        return std::pow(a, b); 
    });
    std::future<int> result = task.get_future();
 
    task(2, 9);
 
    std::cout << "task_lambda:\t" << result.get() << '\n';
}
 
void task_bind()
{
    std::packaged_task<int()> task(std::bind(f, 2, 11));
    std::future<int> result = task.get_future();
 
    task();
 
    std::cout << "task_bind:\t" << result.get() << '\n';
}
 
void task_thread()
{
    std::packaged_task<int(int,int)> task(f);
    std::future<int> result = task.get_future();
 
    std::thread task_td(std::move(task), 2, 10);
    task_td.join();
 
    std::cout << "task_thread:\t" << result.get() << '\n';
}
 
int main()
{
    task_lambda();
    task_bind();
    task_thread();
}

结果输出如下：