先把「异步」这个词拆开。它至少包含三层意思:发起一个任务但不立刻等结果;结果在将来某个时刻可用;等待期间当前线程能去做别的事。C++ 标准库给了前两层的工具,也就是 std::future 和 std::promise,但没有给第三层一个默认的调度器。线程池、事件循环、协程调度,都要自己搭或者用第三方库。
这解释了为什么很多人「用了异步却没变快」。起了一个线程,主线程马上等结果,整体还是串行;或者协程暂停之后没人恢复,任务永远停在那里。工具本身没有错,错在把「有 future」当成「已经异步」。
g++ -std=c++20 -O2,没有额外链接库。涉及 POSIX 线程调度细节的部分,Windows 与 Linux 行为大体一致,但实现不同。future 与 promise:一个存结果,一个取结果
std::promise<T> 是写入端,std::future<T> 是读取端。promise 通过 set_value() 或 set_exception() 把结果放进去,future 通过 get() 取出来。两者通过共享状态关联,future 在结果准备好之前会阻塞等待;wait_for() 可以带超时,避免无限等。
#include <chrono>
#include <future>
#include <iostream>
#include <thread>
int main() {
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread worker([&p] {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
p.set_value(42);
});
if (f.wait_for(std::chrono::seconds(1)) == std::future_status::ready) {
std::cout << "value=" << f.get() << "\n";
}
worker.join();
}
「跑什么、看到什么算通过」:编译运行后应当输出 value=42,大约 100 毫秒后返回。把 set_value() 删掉,wait_for() 会在一秒后返回 timeout,而不是永久卡住;如果直接用 get(),主线程会一直等,这就是「结果永远不来」的典型故障。
几条语义必须记住。get() 只能调用一次,调用后 future 失效;需要多方读取就用 shared_future。promise 在销毁前没有设置值,future 会收到 broken_promise 异常。异常通过 set_exception() 或 std::current_exception() 存进共享状态,get() 时重新抛出,异常类型和值都能保留。
valid() 用来判断 future 是否还关联着共享状态。默认构造的 future 是无效的,调用 get() 会抛 future_error;移动之后原对象也变成无效。很多「偶发抛异常」的代码,其实是把 future 移动走了还在原对象上取值,单线程测试很难发现,因为移动只发生在特定分支。
共享状态是堆上的一个对象,promise 和 future 各持一个指针,最后一个持有者销毁时释放。这意味着 future 可以比创建它的函数活得更久,promise 也可以在线程之间移动。但共享状态本身不提供额外同步,set_value() 和 get() 之间的可见性由标准库保证;你塞进去的引用、指针所指向的数据,仍然要自己保证生命周期。
std::async 的三个坑
std::async 是最省事的入口:传一个可调用对象,返回 future。但它有几个容易踩的语义,不理解就会得出错误结论。
第一,返回的 future 析构时会等待任务完成,效果类似 join()。如果你的 future 是临时对象、没有保存,语句结束就开始等,看起来像「同步调用」。要真正后台执行,必须把 future 保存到生命周期更长的地方,或者明确接受「在这个作用域内等它完成」。
第二,异常如果没人 get(),就被静默丢弃。标准没有要求在析构时抛出或终止,很多实现只是把异常存着,然后随共享状态一起销毁。本机实测的下面的代码,第一段作用域没有任何异常输出,第二段调用 get() 才看到 boom。
#include <future>
#include <iostream>
#include <stdexcept>
int main() {
{
auto f = std::async(std::launch::async, [] {
throw std::runtime_error("boom");
return 42;
});
// 故意不调用 get()
std::cout << "scope1: future destroyed without get\n";
}
{
auto f = std::async(std::launch::async, [] {
throw std::runtime_error("boom");
return 42;
});
try {
(void)f.get();
} catch (const std::exception& e) {
std::cout << "scope2: caught " << e.what() << "\n";
}
}
}
「跑什么、看到什么算通过」:本机实测输出两行,scope1: future destroyed without get 和 scope2: caught boom。第一段没有异常提示,说明错误被吞了。生产代码里要么保存 future 并统一 get(),要么在任务里自己记录异常,不能指望「没输出就是没出错」。
第三,启动策略。std::launch::async 保证在新线程执行;std::launch::deferred 表示延迟到 get()/wait() 时才在当前线程执行;不指定策略时由实现选择,可能是两者之一。想要确定行为就显式传 std::launch::async,别依赖默认值。延迟执行看起来像异步,实际是在调用 get() 的那一刻才跑,等待期间什么也没发生。
std::packaged_task 把可调用对象和 future 绑在一起,适合丢进线程池或队列,由别人决定什么时候执行。它本身不创建线程,也不保证线程安全,多个线程同时调用同一个 task 对象是未定义行为。
std::async 每次调用都可能新建一个线程,循环里起几十个任务就是几十个线程。线程创建、栈内存、上下文切换都是成本,任务很短时反而更慢。需要控制并发就用固定大小的线程池,把任务排队;std::async 适合数量少、生命周期长的后台任务,不适合当通用并发原语。
还有一种危险写法:把 future 放进 detach 的线程里,函数结束就再也没人管结果。任务失败没人知道,程序退出时线程可能还在跑,访问已经销毁的对象。C++ 没有「后台任务自动回收」的机制,任务的所有权和生命周期必须显式设计。
回调不是解法,只是另一种写法
没有 future 之前,异步常用回调:发起操作时传一个函数,完成时调用它。它的问题不在语法,而在控制流。多个操作串起来会形成嵌套,错误处理要在每一层重复;回调对象的生命周期、捕获的引用是否还有效、在哪个线程执行,都要额外约定。
future 风格
把结果封装成可等待的对象,调用方决定什么时候等。适合「发起后还有别的事要做」的场景,但连续依赖需要自己串起来。
回调风格
完成即调用,延迟低、实现简单。嵌套一深就难读,异常传播和生命周期管理都要手工处理。
协程想解决的正是这个可读性问题:让异步代码写起来像顺序代码,暂停点用 co_await 标记。它没有消除异步的复杂度,只是把「状态机」藏到编译器生成的结构里。
回调的生命周期问题值得单独说。回调里捕获 this 或引用,任务完成时对象可能已经销毁,回调就成了悬空访问;捕获 shared_ptr 能延长生命周期,又可能造成循环引用。回调在哪个线程执行也要约定,UI 线程、IO 线程、工作线程对共享数据的访问规则不同。异步框架通常提供「绑定执行器」或「弱引用回调」,就是为了把这些问题集中处理。
C++20 协程是什么
协程函数里出现 co_await、co_yield 或 co_return,编译器就会把它改写成一台状态机:局部变量放进一个「协程帧」,函数入口返回一个句柄,执行到暂停点时保存当前位置,之后通过句柄恢复。帧通常在堆上分配,大小由局部变量决定;编译器优化后也可能放到栈上,但不要假设一定没有分配。
协程的行为由「承诺对象」(promise_type)决定。它规定初始是否暂停、结束时是否暂停、co_yield 的值怎么存、co_return 怎么处理、异常怎么捕获。不同库的 promise_type 不一样,所以同样是 co_await,在 Asio 和某个玩具库里含义可能完全不同。
#include <coroutine>
#include <iostream>
struct Generator {
struct promise_type {
int current = 0;
Generator get_return_object() {
return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
std::suspend_always yield_value(int v) {
current = v;
return {};
}
void return_void() {}
void unhandled_exception() { std::terminate(); }
};
std::coroutine_handle<promise_type> h;
explicit Generator(std::coroutine_handle<promise_type> hh) : h(hh) {}
~Generator() { if (h) h.destroy(); }
bool next() {
h.resume();
return !h.done();
}
int value() const { return h.promise().current; }
};
Generator range(int a, int b) {
for (int i = a; i < b; ++i) co_yield i;
}
int main() {
auto g = range(1, 4);
while (g.next()) std::cout << g.value() << ' ';
std::cout << "\ndone\n";
}
「跑什么、看到什么算通过」:本机实测输出 1 2 3 和 done。这个生成器是「拉取式」的:每次 resume() 才产生下一个值,initial_suspend 让它创建后先不执行。final_suspend 返回 suspend_always,协程结束后帧还在,直到 destroy() 才释放;如果返回 suspend_never,帧会自动销毁,句柄随即失效。
恢复必须有人做。上面的例子是手动 resume();在网络场景里,co_await 一个「读操作」时,awaiter 的 await_suspend 会把句柄注册到事件循环,等 socket 可读时由循环恢复。标准库没有这个循环,所以协程写完了,还得有一个东西去驱动它。没有驱动,程序就停在第一个暂停点,看起来像「什么都没发生」。
co_await 后面跟的是一个 awaiter,它至少提供三个成员:await_ready() 判断是否要暂停,await_suspend(handle) 在暂停时登记恢复方式,await_resume() 给出表达式的结果。理解了这三个函数,就能自己接第三方库:把 await_suspend 里的句柄交给事件循环,事件就绪时调用 resume()。很多「协程库」本质就是替你把这一步封装好。
协程也分有栈和无栈。C++20 的是无栈协程,暂停点由编译器生成状态机,不能在一个函数内部任意位置恢复;有栈协程保存整个调用栈,切换更像线程,但实现依赖平台和汇编。标准库选择无栈是为了可移植和零额外运行时,代价是不能「从任意深度暂停」。
协程不是线程
线程由操作系统调度,抢占式,随时可能切换;协程由代码显式暂停,协作式,只在 co_await/co_yield 处让出。一个线程里可以跑成千上万个协程,切换不需要内核参与,开销小得多。但它们不提供并行:同一时刻,一个线程仍然只执行一个协程。
恢复线程也不固定。一个协程可能在 A 线程创建、B 线程恢复,协程帧里的数据就成了跨线程共享。多个线程同时恢复同一个协程是数据竞争,必须由调度器保证串行,或者加锁。协程切换本身不会自动加内存屏障,跨线程恢复时的可见性要靠同步原语。
异常处理也不一样。协程里没捕获的异常会交给 promise_type::unhandled_exception(),由它决定是存进 future、记录日志还是终止。写协程库时这一步经常被漏掉,结果异常直接 std::terminate,调用方拿不到任何信息。
协程帧的所有权要明确。谁创建、谁恢复、谁销毁,最好由同一个调度器负责;如果多个组件都能 destroy(),很容易出现重复释放或提前释放。常见做法是用一个带引用计数的任务对象包住句柄,最后一个持有者析构时销毁。句柄本身只是一个指针,不会帮你管理生命周期。
异步 IO 的现实方案
C++ 标准库没有事件循环,也没有异步文件/网络 IO。实际项目通常三条路:
- 线程池加阻塞 IO。把慢操作丢给线程池,主线程不阻塞。实现简单,连接数一多线程就成瓶颈。
- 第三方异步库。Asio、libuv 这类库提供事件循环、定时器、异步 socket,协程可以接上去。它们解决的是「谁来恢复」,不是「语法怎么写」。
- 平台 API。Linux 的 epoll、Windows 的 IOCP,自己封装事件循环。控制力最强,跨平台成本也最高。
文件 IO 尤其要注意。很多操作系统没有真正统一的异步文件接口,所谓异步读写可能只是线程池包装。对普通应用,把文件操作放进线程池已经够用;对高吞吐存储服务,才值得研究 io_uring 这类机制。
事件循环里不能做阻塞操作。一个协程恢复后如果直接调用阻塞的 read() 或等锁,整个循环都会被卡住,其他协程全部停摆。这和前面网络那篇说的是同一件事:异步只是把等待挪走,真正执行的回调仍然必须短小。耗时的解析、压缩、加密,应该继续拆成协程让出,或者丢到工作线程。
取消也要提前设计。std::stop_token 和 std::jthread 提供了协作式取消:线程定期检查是否被请求停止,自己决定在哪里退出。异步任务同理,发起时就要想好「用户关页面了怎么办」「下游超时了怎么办」。协程的取消通常通过恢复时传入一个取消状态,awaiter 检查后抛出或返回;没有这一步,任务会一直跑完,资源也被占着。
测异步代码要专门设计。sleep(1) 之类的等待会让测试又慢又不稳,应该用可控的时钟或事件注入,让「时间」在测试里可以拨快。还要覆盖「结果在超时之后才到」「恢复时对象已销毁」这些边界,这些才是异步代码真正出错的地方。
现象、真实原因、第一步查什么
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
用了 std::async 却像同步 | future 是临时对象,析构时等待任务完成 | future 是否保存到作用域外;启动策略是否显式 async |
| 后台任务出错但主线程不知道 | 异常存在 future 里,没人 get() 就丢了 | 是否统一收集并调用 get(),或任务内自行记录 |
get() 永远不返回 | promise 没设值、协程没人恢复、任务死锁 | 用 wait_for() 加超时定位;查共享状态是否被销毁 |
第二次 get() 抛异常 | 普通 future 只能取一次 | 是否该用 shared_future |
| 协程创建后什么都不执行 | initial_suspend 暂停了,没人 resume() | 是否有事件循环或手动恢复;promise_type 的初始策略 |
| 协程结束就崩溃 | final_suspend 返回 never 后仍访问句柄 | 句柄生命周期与 destroy() 的调用位置 |
| 多线程恢复同一协程偶发数据错乱 | 协程被并发恢复,帧内数据竞争 | 调度器是否保证同一协程串行 |
| 异常直接终止程序 | unhandled_exception() 里调用了 terminate | 承诺对象是否把异常存起来交给调用方 |
边界与代价
- future 析构会阻塞。它保证了资源不泄漏,也让「发射后不管」变得不可能;需要后台长任务时,要自己管理线程或任务对象。
- 异常必须有人接收。异步任务的错误不会自动冒泡,统一的结果收集和日志是必需品。
- 协程帧有内存成本。大量短命协程可能带来分配压力,热路径要测;编译器优化能帮一部分,但不能依赖。
- 协程不提供调度。没有事件循环或线程池,
co_await只是暂停,不会让任何事发生。 - 可读性提升不等于复杂度消失。暂停点、生命周期、跨线程恢复、取消,仍然要逐个设计。
- 取消要贯穿整条链。只给最外层发停止信号,内层还在等 I/O,看起来取消了其实还在跑;每一层都要把
stop_token或取消标志传下去。判断标准很直接:调用取消之后,内层循环必须在有限时间内退出,否则就是漏传了;这类问题压测时通常不报错,只表现为进程退不干净。
当天能自己验证的练习
- 编译本文的 promise 示例,把
set_value()注释掉,分别用get()和wait_for()观察行为差异。 - 写一个
std::async抛异常的例子,一次保存 future 并get(),一次不保存,对比输出。 - 把
std::launch::deferred和std::launch::async各跑一次,打印线程 id,确认是否真的开了新线程。 - 编译本文的生成器协程,改成
final_suspend返回suspend_never,观察析构时是否重复销毁。 - 用线程池执行十个阻塞任务,记录总耗时;再串行执行,比较两者,理解「并发不是让单个任务变快」。
小结
三句话:future 是结果容器,析构会等,异常要 get();协程是编译器生成的状态机,暂停之后必须有人恢复;标准库没有事件循环,异步 IO 要靠线程池或第三方库。
任务能在同一进程里并发之后,下一个问题是跨进程共享数据:两个进程怎么传一大块内存、怎么通知对方、怎么避免读到半更新。下一篇讲共享内存与 IPC,从管道、mmap 到信号量和消息队列。