【C++】std::promise

std::promise

std::promise是C++11并发编程中常用的一个类，常配合std::future使用。其作用是在一个线程中保存一个类型typename T的值，可供绑定的std::future对象在另一线程中获取该值。
假设线程 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;
}

std::async

std::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';
}

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();
}