协程 co_await 挂起点分析 ​

面试考点 ​

co_await 是 C++20 协程的核心机制。面试官通过这道题考察你是否理解 co_await 的展开过程:编译器如何调用 awaiter 的三个函数(await_ready、await_suspend、await_resume),以及挂起点的状态保存和恢复。

核心概念 ​

co_await expr 不是简单的函数调用,编译器会将它展开为一系列步骤:先获取 awaiter 对象,调用 await_ready() 判断是否需要挂起,如果需要挂起则调用 await_suspend() 并保存状态,恢复时调用 await_resume() 获取结果。每个 co_await 都是一个潜在的挂起点。

co_await 展开过程 ​

步骤动作说明
获取 awaiter调用 operator co_await 或直接使用表达式得到 awaiter 对象
await_ready()返回 booltrue 则跳过挂起,直接执行 await_resume
await_suspend(handle)保存协程状态返回 void/bool/coroutine_handle
挂起控制权返回调用者协程帧保存在堆上
恢复handle.resume() 被调用从挂起点继续
await_resume()获取 co_await 的结果可以返回任意类型

基本示例 ​

cpp
#include <iostream>
#include <coroutine>
#include <string>
#include <thread>
#include <chrono>

// ============================
// 示例1:co_await 的编译器展开
// ============================

/*
用户代码:
  co_await some_awaitable;

编译器展开为(伪代码):
  {
      auto&& awaitable = some_awaitable;
      auto&& awaiter = get_awaiter(awaitable);  // 可能调用 operator co_await

      if (!awaiter.await_ready()) {
          // 保存协程状态到帧
          <suspend-coroutine>

          // 调用 await_suspend
          // 根据返回类型有三种行为:
          awaiter.await_suspend(coroutine_handle);

          // 控制权返回给调用者/恢复者
          <return-to-caller-or-resumer>
      }

      // 恢复后(或没挂起时)执行
      auto result = awaiter.await_resume();
      // result 就是 co_await 表达式的值
  }
*/

// ============================
// 示例2:自定义 awaiter
// ============================

// 一个简单的 awaiter,演示三个函数的调用时机
struct TracingAwaiter {
    const char* name;

    TracingAwaiter(const char* n) : name(n) {}

    // 第一步:是否需要挂起?
    bool await_ready() const noexcept {
        std::cout << name << "::await_ready() 被调用" << std::endl;
        return false;  // false = 需要挂起
    }

    // 第二步:挂起时的操作
    void await_suspend(std::coroutine_handle<> handle) const noexcept {
        std::cout << name << "::await_suspend() 被调用" << std::endl;
        // 这里可以:
        // 1. 什么都不做(协程暂停,等待外部 resume)
        // 2. 把 handle 存起来,稍后恢复
        // 3. 立即调用 handle.resume()(等于没挂起)
        // 4. 调用另一个协程的 handle.resume()
    }

    // 第三步:恢复时获取结果
    int await_resume() const noexcept {
        std::cout << name << "::await_resume() 被调用" << std::endl;
        return 42;  // co_await 表达式的值
    }
};

// 简单的协程返回类型
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_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;
    ~SimpleTask() { if (handle) handle.destroy(); }
    SimpleTask(std::coroutine_handle<promise_type> h) : handle(h) {}
    SimpleTask(SimpleTask&& o) noexcept : handle(o.handle) { o.handle = nullptr; }
    SimpleTask(const SimpleTask&) = delete;
    void resume() { if (handle && !handle.done()) handle.resume(); }
};

SimpleTask tracing_coroutine() {
    std::cout << "协程开始" << std::endl;

    // 第一个挂起点
    int result = co_await TracingAwaiter("Awaiter1");
    std::cout << "Awaiter1 返回: " << result << std::endl;

    // 第二个挂起点
    co_await TracingAwaiter("Awaiter2");
    std::cout << "协程结束" << std::endl;
}

void tracing_demo() {
    auto task = tracing_coroutine();
    // 输出:协程开始 → Awaiter1::await_ready → Awaiter1::await_suspend
    // 协程在第一个 co_await 处挂起

    std::cout << "--- 第一次 resume ---" << std::endl;
    task.resume();
    // 输出:Awaiter1::await_resume → 返回 42 → Awaiter2::await_ready → Awaiter2::await_suspend

    std::cout << "--- 第二次 resume ---" << std::endl;
    task.resume();
    // 输出:Awaiter2::await_resume → 协程结束
}

// ============================
// 示例3:await_suspend 的三种返回类型
// ============================

// 返回 void:无条件挂起
struct SuspendAlways {
    bool await_ready() { return false; }
    void await_suspend(std::coroutine_handle<>) {}  // 无条件挂起
    void await_resume() {}
};

// 返回 bool:条件挂起
struct ConditionalSuspend {
    bool should_suspend;

    bool await_ready() { return false; }
    bool await_suspend(std::coroutine_handle<>) {
        // 返回 true:挂起
        // 返回 false:不挂起,立即恢复
        return should_suspend;
    }
    void await_resume() {}
};

// 返回 coroutine_handle:对称转移(symmetric transfer)
struct SymmetricTransfer {
    std::coroutine_handle<> target;

    bool await_ready() { return false; }
    std::coroutine_handle<> await_suspend(std::coroutine_handle<>) {
        // 返回另一个协程的 handle,控制权转移给它
        // 避免了栈溢出(不递归调用 resume)
        if (target) return target;
        return std::noop_coroutine();  // 没有目标时返回调用者
    }
    void await_resume() {}
};

// ============================
// 示例4:await_ready 的优化作用
// ============================

// 模拟异步操作:可能已经完成
struct AsyncRead {
    bool completed_ = false;
    std::string data_;

    bool await_ready() const noexcept {
        // 如果数据已经就绪,跳过挂起(性能优化)
        return completed_;
    }

    void await_suspend(std::coroutine_handle<> handle) noexcept {
        // 模拟异步操作
        // 实际中会注册回调,操作完成后调用 handle.resume()
        data_ = "async data";
        completed_ = true;
        handle.resume();  // 模拟立即完成
    }

    std::string await_resume() {
        return std::move(data_);
    }
};

// ============================
// 示例5:co_await 表达式的值
// ============================

struct ValueAwaiter {
    int value;

    bool await_ready() { return true; }  // 不挂起
    void await_suspend(std::coroutine_handle<>) {}
    int await_resume() { return value; }  // 返回值就是 co_await 的结果
};

SimpleTask value_coroutine() {
    // co_await 可以有返回值
    int a = co_await ValueAwaiter{10};
    int b = co_await ValueAwaiter{20};
    std::cout << "a + b = " << a + b << std::endl;
}

// ============================
// 示例6:标准库的 awaiter
// ============================

/*
std::suspend_always:
    await_ready() → false  (总是挂起)
    await_suspend() → void (无条件挂起)
    await_resume() → void  (没有返回值)

std::suspend_never:
    await_ready() → true   (从不挂起)
    await_suspend() → void
    await_resume() → void

std::noop_coroutine_handle:
    resume() 什么都不做
    用于 await_suspend 返回时表示"返回调用者"
*/

// ============================
// 示例7:operator co_await 定制
// ============================

struct MyAwaitable {
    int data;

    // 定义 operator co_await 来提供自定义 awaiter
    auto operator co_await() {
        struct Awaiter {
            int& data;
            bool await_ready() { return false; }
            void await_suspend(std::coroutine_handle<>) {}
            int await_resume() { return data * 2; }
        };
        return Awaiter{data};
    }
};

SimpleTask operator_demo_coro() {
    MyAwaitable obj{21};
    int result = co_await obj;  // 调用 obj.operator co_await()
    std::cout << "operator co_await 结果: " << result << std::endl;  // 42
}

int main() {
    std::cout << "=== 挂起点追踪 ===" << std::endl;
    tracing_demo();

    std::cout << "\n=== 值传递 ===" << std::endl;
    {
        auto task = value_coroutine();
    }

    std::cout << "\n=== operator co_await ===" << std::endl;
    {
        auto task = operator_demo_coro();
        task.resume();
    }

    return 0;
}

await_suspend 返回类型的行为 ​

返回类型行为
void无条件挂起,控制权返回给 resume 的调用者
booltrue 则挂起,false 则立即恢复(不挂起)
coroutine_handle<>对称转移:恢复返回的 handle 对应的协程

获取 awaiter 的查找顺序 ​

优先级查找方式
最高promise.await_transform(expr),然后对结果执行下面的查找
中expr.operator co_await()(成员函数)
中operator co_await(expr)(自由函数,通过 ADL)
最低直接使用 expr 作为 awaiter

常见问题 ​

await_ready 返回 true 和不写 co_await 有什么区别?

await_ready 返回 true 时仍然会调用 await_resume(),可以获取返回值。只是跳过了 await_suspend,不会挂起协程。这是一种性能优化:当异步操作已经同步完成时,避免不必要的挂起和恢复开销。

对称转移(symmetric transfer)解决什么问题?

如果 await_suspend 内部直接调用 handle.resume(),每次恢复都会增加调用栈深度,大量协程链式恢复会导致栈溢出。对称转移通过返回 coroutine_handle,让编译器在不增加栈深度的情况下切换到另一个协程(尾调用优化)。

co_await 可以出现在什么位置?

co_await 可以出现在协程函数体的任何表达式位置,包括 if 条件、for 循环、函数参数等。但不能出现在 catch 块、constexpr 函数、构造函数/析构函数中。

适用场景 ​

  • 异步 I/O(网络读写、文件操作)
  • 定时器等待
  • 协程间的同步(信号量、事件)
  • 惰性生成器(co_yield 内部也是 co_await)

注意事项 ​

  • await_suspend 中如果立即 resume 当前 handle,要小心递归
  • final_suspend 的 awaiter 不能抛异常(声明为 noexcept)
  • await_suspend 中协程已经挂起,访问局部变量需要通过 handle
  • 自定义 awaiter 的析构时机要注意
  • 对称转移需要编译器支持尾调用优化

总结 ​

co_await 是 C++20 协程的核心,编译器将其展开为 await_ready → await_suspend → await_resume 三步调用。await_ready 决定是否需要挂起(性能优化),await_suspend 处理挂起逻辑(三种返回类型对应不同行为),await_resume 提供 co_await 表达式的值。面试中要能画出 co_await 的展开流程、解释三种 await_suspend 返回类型的区别、以及对称转移解决栈溢出的原理。