先把「异步」这个词拆开。它至少包含三层意思:发起一个任务但不立刻等结果;结果在将来某个时刻可用;等待期间当前线程能去做别的事。C++ 标准库给了前两层的工具,也就是 std::future 和 std::promise,但没有给第三层一个默认的调度器。线程池、事件循环、协程调度,都要自己搭或者用第三方库。

这解释了为什么很多人「用了异步却没变快」。起了一个线程,主线程马上等结果,整体还是串行;或者协程暂停之后没人恢复,任务永远停在那里。工具本身没有错,错在把「有 future」当成「已经异步」。

本机用 g++ 16(MinGW,Windows)编译运行了 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) 之类的等待会让测试又慢又不稳,应该用可控的时钟或事件注入,让「时间」在测试里可以拨快。还要覆盖「结果在超时之后才到」「恢复时对象已销毁」这些边界,这些才是异步代码真正出错的地方。

不要为了「异步」把每个小操作都拆成协程。协程帧有分配成本,切换有开销,调试也更难。IO 等待占比不高时,直接同步写反而更简单。

现象、真实原因、第一步查什么

你看到的现象真实原因第一步查什么
用了 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 到信号量和消息队列。