c++如何使用std::future和std::promise_c++异步编程future/promise指南

尼克

发布时间：2025-09-18 10:50:01

941人浏览过

来源于php中文网

原创

std::future和std::promise用于C++异步编程，前者获取结果，后者设置结果；通过创建promise、获取future、启动线程、设置值或异常、最后get获取结果实现；get阻塞可用wait_for避免；异常通过set_exception传递；shared_future允许多次get；async封装了future/promise简化使用；需注意数据线程安全及promise生命周期。

c++如何使用std::future和std::promise_c++异步编程future/promise指南

C++ 中

std::future

和

std::promise

是实现异步编程的关键工具。它们允许你在不同的线程之间传递数据和状态，而无需显式地使用锁或条件变量。简单来说，

std::promise

负责设置异步操作的结果，而

std::future

负责获取这个结果。

解决方案

要使用

std::future

和

std::promise

进行异步编程，你需要遵循以下步骤：

创建
```
std::promise
```
对象：
```
std::promise
```
对象用于设置异步操作的结果。你需要指定结果的类型。例如，如果你要异步计算一个整数，可以创建一个
```
std::promise
```
对象。

立即学习“C++免费学习笔记（深入）”；
获取
```
std::future
```
对象： 从
```
std::promise
```
对象中获取一个
```
std::future
```
对象。
```
std::future
```
对象允许你稍后获取异步操作的结果。
启动异步任务： 将异步任务提交给一个新线程或线程池。在这个任务中，你需要使用
```
std::promise
```
对象来设置结果。
设置结果： 在异步任务中，使用
```
std::promise::set_value()
```
方法设置结果。如果异步任务抛出异常，可以使用
```
std::promise::set_exception()
```
方法设置异常。
获取结果： 在主线程中，使用
```
std::future::get()
```
方法获取异步操作的结果。
```
get()
```
方法会阻塞，直到结果可用。如果异步任务抛出了异常，
```
get()
```
方法会重新抛出该异常。

下面是一个简单的示例：

#include 
#include 
#include 

int calculate_sum(int a, int b) {
    // 模拟耗时操作
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return a + b;
}

int main() {
    std::promise promise;
    std::future future = promise.get_future();

    std::thread t([&promise]() {
        try {
            int result = calculate_sum(5, 3);
            promise.set_value(result);
        } catch (...) {
            promise.set_exception(std::current_exception());
        }
    });

    try {
        int sum = future.get();
        std::cout << "Sum: " << sum << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }

    t.join();

    return 0;
}

副标题1

std::future

的

get()

方法会阻塞，如何避免阻塞？

可以使用

std::future::wait_for()

或

std::future::wait_until()

方法来避免无限期阻塞。这些方法允许你指定一个超时时间。如果在超时时间内结果不可用，它们会返回一个

std::future_status

值，指示超时或结果已准备好。

#include 
#include 
#include 
#include 

int main() {
    std::promise promise;
    std::future future = promise.get_future();

    std::thread t([&promise]() {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        promise.set_value(42);
    });

    // 等待最多2秒
    auto status = future.wait_for(std::chrono::seconds(2));

    if (status == std::future_status::ready) {
        std::cout << "Result: " << future.get() << std::endl;
    } else if (status == std::future_status::timeout) {
        std::cout << "Timeout: Result not available yet." << std::endl;
    } else {
        std::cout << "Deferred." << std::endl;
    }

    t.join();
    return 0;
}

副标题2

燕雀Logo

为用户提供LOGO免费设计在线生成服务

下载

std::promise

和

std::future

如何处理异常？

std::promise

允许你使用

set_exception()

方法设置一个异常。

std::future

的

get()

方法会重新抛出这个异常。这允许你将异步操作中的异常传递回主线程。

std::current_exception()

可以捕获当前线程的异常并将其存储起来，以便稍后通过

std::promise

传递。

#include 
#include 
#include 
#include 

int main() {
    std::promise promise;
    std::future future = promise.get_future();

    std::thread t([&promise]() {
        try {
            throw std::runtime_error("Something went wrong in the thread!");
        } catch (...) {
            promise.set_exception(std::current_exception());
        }
    });

    try {
        future.get(); // 这会抛出 std::runtime_error
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

副标题3

std::shared_future

和

std::future

有什么区别？什么时候应该使用

std::shared_future

？

std::future

只能被

get()

调用一次，之后就失效了。

std::shared_future

可以被多个线程共享，并且每个线程都可以多次调用

get()

(或者

wait()

等)。

如果你需要多个线程访问同一个异步操作的结果，应该使用

std::shared_future

。

std::shared_future

允许你创建多个对同一个结果的引用。

#include 
#include 
#include 
#include 

int main() {
    std::promise promise;
    std::future future = promise.get_future();
    std::shared_future shared_future = future.share();

    std::vector threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back([shared_future, i]() {
            std::cout << "Thread " << i << ": " << shared_future.get() << std::endl;
        });
    }

    promise.set_value(123);

    for (auto& t : threads) {
        t.join();
    }

    return 0;
}

副标题4

std::async

和

std::future/std::promise

的关系是什么？

std::async

是一个高层次的异步操作启动函数，它内部使用了

std::future

和

std::promise

。当你调用

std::async

时，它会自动创建一个

std::promise

，启动一个异步任务，并将

std::promise

关联的

std::future

返回给你。

std::async

简化了异步编程，你不需要手动创建

std::promise

和

std::thread

。但是，如果你需要更精细的控制（例如，自定义线程池或异常处理），那么手动使用

std::future

和

std::promise

可能会更好。

#include 
#include 

int calculate_product(int a, int b) {
    std::cout << "Calculating product in a separate thread." << std::endl;
    return a * b;
}

int main() {
    std::future future = std::async(std::launch::async, calculate_product, 7, 6);

    std::cout << "Waiting for the result..." << std::endl;
    int product = future.get();
    std::cout << "Product: " << product << std::endl;

    return 0;
}

副标题5

使用