std::promise

std::promise：用于获取线程中变量的结果，如下：

#include <iostream>
#include <thread>
#include <future>

void printMessage(std::promise<std::string>&& prms, std::string message) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    prms.set_value(message); // 设置promise的值
}

int main() {
    std::promise<std::string> prms; // 创建一个promise对象
    std::future<std::string> ftr = prms.get_future(); // 获取与promise关联的future对象

    std::thread t(printMessage, std::move(prms), "Hello, std::promise!"); // 在新线程中调用printMessage函数

    std::cout << "Waiting for the message..." << std::endl;
    std::string message = ftr.get(); // 等待并获取future的值
    std::cout << "Received message: " << message << std::endl;

    t.join();

    return 0;
}

在线程函数中给外面传进来的promise对象，当线程函数执行完成之后就可以通过promis获取该值了，值得注意的是取值是间接的通过promise内部提供的future来获取的。

std::future

获取future结果有三种方式：get、wait、wait_for，其中get等待异步操作结束并返回结果；wait只是等待异步操作完成，没有返回值；wait_for是等待异步操作完成，然后再等几秒钟再返回结果。

future_status有三种状态：

deferred：异步操作还没开始
ready：异步操作已经完成
timeout：异步操作超时

//查询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);

std::packaged_task

std::packaged_task获取线程函数的返回值，如下：

#include <iostream>
#include <thread>
#include <future>
#include <functional>

int add(int a, int b) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return a + b;
}

int main() {
    std::packaged_task<int(int, int)> task(add); // 创建一个packaged_task，将add函数作为可调用对象
    std::future<int> future = task.get_future(); // 获取与packaged_task关联的future对象

    std::thread t(std::move(task), 3, 4); // 在新线程中调用packaged_task

    std::cout << "Waiting for the result..." << std::endl;
    int result = future.get(); // 等待并获取future的值
    std::cout << "Result: " << result << std::endl;

    t.join();

    return 0;
}

std::async

std::async：std::async是将线程创建和std::promise封装了在一起（我的理解）

#include <iostream>
#include <future>

int add(int a, int b) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return a + b;
}

int main() {
    std::future<int> future = std::async(add, 3, 4); // 异步执行add函数，并返回future对象

    std::cout << "Waiting for the result..." << std::endl;
    int result = future.get(); // 等待并获取future的值
    std::cout << "Result: " << result << std::endl;

    return 0;
}

参考：连接1