C++异步并发编程future、promise和packaged_task三者的区别和联系

在C++中，std::future、std::promise和std::packaged_task是用于并发编程的工具，它们用于处理异步操作、线程间通信以及任务的封装。下面我将分别解释它们的作用，并给出相应的代码示例：

std::future:

std::future是一个用于表示异步操作结果的对象。它通常与std::async结合使用，用于获取异步任务的结果。
std::future提供了一种在一个线程中等待另一个线程完成工作的机制。

#include 
#include 

int foo() {
    return 42;
}

int main() {
    std::future<int> result = std::async(foo);
    std::cout << "Waiting for the result..." << std::endl;
    int value = result.get();
    std::cout << "Result: " << value << std::endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

std::promise:

std::promise是用于在一个线程中设置值，然后通过相关联的std::future在另一个线程中获取值的机制。
std::promise允许你在一个线程中产生结果，并在另一个线程中获取。

#include 
#include 
#include 

void setValue(std::promise<int>& prom) {
    prom.set_value(42);
}

int main() {
    std::promise<int> prom;
    std::future<int> result = prom.get_future();

    std::thread worker(setValue, std::ref(prom));

    // Do some other work...

    int value = result.get();
    std::cout << "Result: " << value << std::endl;

    worker.join();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

std::packaged_task:

std::packaged_task是一个可调用对象的封装，它可以被异步调用，并且可以与std::future结合使用。
std::packaged_task可以包装任何可调用对象，使其能够像函数一样异步执行。

#include 
#include 

int foo() {
    return 42;
}

int main() {
    std::packaged_task<int()> task(foo);
    std::future<int> result = task.get_future();

    std::thread worker(std::move(task));

    // Do some other work...

    int value = result.get();
    std::cout << "Result: " << value << std::endl;

    worker.join();
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

总的来说，std::future用于获取异步操作的结果，std::promise用于在一个线程中设置值以供另一个线程获取，而std::packaged_task允许你异步执行任何可调用对象。这三者在不同的情境下提供了对异步编程的不同支持。