19、异步编程模型:std::future/promise、std::async、协程(C++20)入门
说到异步编程,很多C++开发者第一反应就是「线程池+回调」。说实话,我早年也是这么干的。直到有一次我在一个交易系统里,回调嵌套了五六层,调试时差点把自己绕晕。嗯,从那以后我就开始认真研究C++标准库提供的异步方案了。
这一章,咱们聊聊C++里三种主流的异步编程手段:std::future/promise、std::async,还有C++20引入的协程。它们各有各的适用场景,用好了能让你的代码既高效又清爽。
19.1 为什么需要异步编程?
先问个问题:你写过一个函数,调用后要等好几秒才返回吗?比如读取一个大文件、请求网络数据、或者做一次复杂的计算。
同步模式下,主线程就卡在那儿了。用户界面无响应,其他任务也排着队干等。这显然不是我们想要的。
异步编程的核心思想很简单:把耗时操作丢到后台去跑,主线程继续干别的事。等后台完事了,再通知主线程取结果。
我个人习惯把异步编程比作「点外卖」。你下单(发起异步任务),然后该干嘛干嘛(继续执行主逻辑)。外卖到了(任务完成),你取餐(获取结果)。多顺畅。
19.2 std::future 和 std::promise:最基础的异步通道
std::future 和 std::promise 是一对搭档。它们共同实现了一个「生产者-消费者」模型:
- promise:生产者,负责在后台线程里设置一个值(或异常)。
- future:消费者,负责在需要的时候获取这个值。
说白了,promise 就是「我答应你,将来会把结果给你」。future 就是「我等着你兑现承诺」。
19.2.1 基本用法
#include <iostream>
#include <future>
#include <thread>
#include <chrono>
int main() {
// 创建一个 promise 和对应的 future
std::promise<int> prom;
std::future<int> fut = prom.get_future();
// 启动一个线程,执行耗时计算
std::thread t([&prom]() {
std::this_thread::sleep_for(std::chrono::seconds(2));
prom.set_value(42); // 设置结果
});
// 主线程可以干点别的事...
std::cout << "主线程继续工作..." << std::endl;
// 需要结果时,调用 get() 获取
int result = fut.get(); // 这里会阻塞,直到 promise 设置了值
std::cout << "结果: " << result << std::endl;
t.join();
return 0;
}
你看,主线程在调用 fut.get() 之前,可以自由地做其他事情。这就是异步的魅力。
future::get() 只能调用一次。如果你需要多次检查结果是否就绪,可以用 future::wait_for() 或 future::valid()。
19.2.2 传递异常
我在项目中遇到过一种情况:后台任务可能抛出异常。如果直接让线程崩溃,那整个程序就挂了。promise 提供了优雅的异常传递机制:
std::promise<int> prom;
std::future<int> fut = prom.get_future();
std::thread t([&prom]() {
try {
// 模拟一个可能出错的操作
throw std::runtime_error("数据读取失败");
prom.set_value(100); // 不会执行到这里
} catch(...) {
prom.set_exception(std::current_exception()); // 传递异常
}
});
try {
int result = fut.get(); // 这里会重新抛出异常
} catch(const std::exception& e) {
std::cerr << "捕获异常: " << e.what() << std::endl;
}
t.join();
嗯,这里要注意:set_exception 必须在 promise 被销毁前调用,否则 future 那边会得到一个「broken promise」异常。
19.3 std::async:更高级的异步任务
说实话,手动管理 promise 和 thread 有点繁琐。大多数时候,我们只是想让一个函数异步执行,然后拿结果。std::async 就是干这个的。
19.3.1 基本用法
#include <iostream>
#include <future>
int compute(int x) {
std::this_thread::sleep_for(std::chrono::seconds(1));
return x * x;
}
int main() {
// 异步启动 compute 函数
std::future<int> fut = std::async(std::launch::async, compute, 10);
std::cout << "主线程继续..." << std::endl;
int result = fut.get(); // 等待结果
std::cout << "计算结果: " << result << std::endl;
return 0;
}
你看,代码简洁多了。不用手动创建线程,不用管理 promise,一个 std::async 全搞定。
19.3.2 启动策略
std::async 有两个启动策略,我建议你根据场景选择:
| 策略 | 含义 | 适用场景 |
|---|---|---|
std::launch::async |
强制在新线程上异步执行 | 需要真正的并行,任务耗时较长 |
std::launch::deferred |
延迟执行,直到调用 get() 或 wait() |
任务可能不需要执行,或者想控制执行时机 |
std::launch::async | std::launch::deferred,由实现决定。我曾经在一个项目中因为这个默认行为踩过坑——某些平台上任务被延迟执行了,导致性能不符合预期。所以,我建议你总是显式指定策略。
19.4 C++20 协程:轻量级异步新范式
协程是C++20引入的重磅特性。说实话,刚接触时我觉得它有点抽象。但用多了就会发现,它比回调式的异步编程优雅太多了。
协程的核心思想是:一个函数可以暂停执行,把控制权交还给调用者,然后在合适的时候恢复执行。 你想想看,这不就是异步编程的天然模型吗?
19.4.1 协程的基本概念
C++20 的协程是「无栈协程」。它不像线程那样有独立的栈空间,而是通过编译器生成的代码来保存和恢复执行状态。这意味着:
- 创建和切换开销极低:比线程轻量得多
- 可以创建成千上万个:线程可不敢这么玩
- 需要手动管理生命周期:嗯,这是代价
19.4.2 一个简单的协程示例
先看一个最简单的协程:
#include <iostream>
#include <coroutine>
#include <future>
// 一个简单的协程返回类型
struct SimpleTask {
struct promise_type {
SimpleTask get_return_object() {
return SimpleTask{std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_never initial_suspend() { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void return_void() {}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> handle;
explicit SimpleTask(std::coroutine_handle<promise_type> h) : handle(h) {}
~SimpleTask() { if (handle) handle.destroy(); }
};
// 一个协程函数
SimpleTask myCoroutine() {
std::cout << "协程开始执行" << std::endl;
co_await std::suspend_always{}; // 暂停
std::cout << "协程恢复执行" << std::endl;
}
int main() {
auto task = myCoroutine(); // 创建协程,执行到第一个暂停点
std::cout << "主线程继续..." << std::endl;
// 这里协程已经执行完了,因为 final_suspend 返回 suspend_never
return 0;
}
你可能会觉得这个例子有点复杂。没错,C++20 的协程暴露了太多底层细节。不过别担心,实际项目中我们通常会用封装好的库,比如 cppcoro 或者自己封装一层。
19.4.3 协程的实际应用场景
我在一个网络库项目中用过协程。传统的异步网络编程,要么用回调(回调地狱),要么用状态机(代码难以维护)。用协程后,代码写起来就像同步一样自然:
// 伪代码,展示协程的优雅
Task<void> handleConnection(Connection conn) {
auto request = co_await conn.readRequest(); // 异步读,暂停
auto response = processRequest(request);
co_await conn.sendResponse(response); // 异步写,暂停
// 协程自动结束
}
你看,每一行 co_await 就是一个异步操作。代码读起来就像同步顺序执行一样,但实际上每个 co_await 都会暂停协程,让出线程给其他协程使用。
19.5 如何选择?
说了这么多,到底该用哪个?我个人的经验是这样的:
- 简单的异步任务:用
std::async,最省事 - 需要精细控制线程生命周期:用
std::promise/future+ 手动线程管理 - 复杂的异步流程,比如多个异步操作串联:用协程,代码最清晰
- 高性能场景,需要大量并发连接:协程是首选,线程开销太大
我曾经在一个项目中,用 std::async 处理了上百个并发任务。结果发现线程创建销毁的开销比任务本身还大。后来改用协程,性能提升了三倍多。嗯,选对工具真的很重要。
19.6 避坑指南
最后,分享几个我踩过的坑:
std::shared_future。
std::move 转移所有权。
initial_suspend 和 final_suspend 的返回值,决定了协程的行为。搞错了会导致内存泄漏或崩溃。
好了,这一章的内容就到这里。异步编程是C++进阶的必修课,掌握了它,你就能写出更高效、更优雅的并发代码。下一章,咱们聊聊更高级的并发模式——线程池和任务队列。