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是实现异步编程的关键工具。它们允许你在不同的线程之间传递数据和状态，而无需显式地使用锁或条件变量。简单来说，
std::promise负责设置异步操作的结果，而
std::future负责获取这个结果。
解决方案
要使用
std::future和
std::promise进行异步编程，你需要遵循以下步骤：
-
创建
std::promise
对象：std::promise
对象用于设置异步操作的结果。你需要指定结果的类型。例如，如果你要异步计算一个整数，可以创建一个std::promise<int>
对象。立即学习“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 <iostream>
#include <future>
#include <thread>
int calculate_sum(int a, int b) {
// 模拟耗时操作
std::this_thread::sleep_for(std::chrono::seconds(2));
return a + b;
}
int main() {
std::promise<int> promise;
std::future<int> 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 <iostream>
#include <future>
#include <chrono>
#include <thread>
int main() {
std::promise<int> promise;
std::future<int> 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
std::promise和
std::future如何处理异常？
std::promise允许你使用
set_exception()方法设置一个异常。
std::future的
get()方法会重新抛出这个异常。这允许你将异步操作中的异常传递回主线程。
std::current_exception()可以捕获当前线程的异常并将其存储起来，以便稍后通过
std::promise传递。
#include <iostream>
#include <future>
#include <thread>
#include <stdexcept>
int main() {
std::promise<int> promise;
std::future<int> 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 <iostream>
#include <future>
#include <thread>
#include <vector>
int main() {
std::promise<int> promise;
std::future<int> future = promise.get_future();
std::shared_future<int> shared_future = future.share();
std::vector<std::thread> 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 <iostream>
#include <future>
int calculate_product(int a, int b) {
std::cout << "Calculating product in a separate thread." << std::endl;
return a * b;
}
int main() {
std::future<int> 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
使用
std::future和
std::promise时需要注意哪些线程安全问题？
std::promise和
std::future本身是线程安全的，但你需要注意它们所操作的数据的线程安全性。例如，如果你在异步任务中修改一个共享变量，你需要使用锁来保护这个变量。另外，确保在
std::promise对象销毁之前设置结果或异常，否则会导致未定义行为。 避免在多个线程中同时调用同一个
std::promise对象的
set_value或
set_exception方法。
