协程状态机转换过程 ​

面试考点 ​

C++20 协程是面试中的进阶话题。面试官通过这道题考察你是否理解编译器如何将协程函数转换为状态机、协程帧的结构、以及 co_await/co_yield/co_return 的底层机制。

核心概念 ​

当编译器发现一个函数包含 co_await、co_yield 或 co_return 关键字时,它会将这个函数转换为一个状态机。每个挂起点(suspend point)对应状态机的一个状态。协程的局部变量被保存在堆分配的"协程帧"(coroutine frame)中,以便在恢复时使用。

协程转换的关键组件 ​

组件作用
协程帧(coroutine frame)堆分配的内存,存储局部变量、promise 对象、挂起点索引
promise_type控制协程行为的类型(initial_suspend, final_suspend, return_value 等)
coroutine_handle指向协程帧的句柄,用于恢复和销毁协程
awaiter控制 co_await 行为的对象(await_ready, await_suspend, await_resume)

基本示例 ​

cpp
#include <iostream>
#include <coroutine>
#include <optional>

// ============================
// 示例1:一个简单的协程及其转换过程
// ============================

// 协程返回类型
struct Task {
    struct promise_type {
        // 协程创建时调用,返回 Task 对象给调用者
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }

        // 协程开始时是否挂起(suspend_always = 挂起,suspend_never = 不挂起)
        std::suspend_always initial_suspend() { return {}; }

        // 协程结束时是否挂起
        std::suspend_always final_suspend() noexcept { return {}; }

        // co_return 时调用
        void return_void() {}

        // 异常处理
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

    explicit Task(std::coroutine_handle<promise_type> h) : handle(h) {}

    ~Task() {
        if (handle) handle.destroy();
    }

    // 禁止拷贝
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;

    // 允许移动
    Task(Task&& other) noexcept : handle(other.handle) {
        other.handle = nullptr;
    }

    void resume() {
        if (handle && !handle.done()) {
            handle.resume();
        }
    }

    bool done() const {
        return handle.done();
    }
};

// 原始协程函数
Task my_coroutine() {
    std::cout << "步骤 1" << std::endl;
    co_await std::suspend_always{};  // 挂起点 1
    std::cout << "步骤 2" << std::endl;
    co_await std::suspend_always{};  // 挂起点 2
    std::cout << "步骤 3" << std::endl;
    // co_return(隐式)
}

/*
编译器将上面的协程转换为类似以下的状态机(伪代码):

struct my_coroutine_frame {
    // 协程帧内容
    promise_type promise;
    int suspend_index = 0;  // 当前挂起点
    // 局部变量也存在这里

    void resume() {
        switch (suspend_index) {
            case 0: goto initial_suspend;
            case 1: goto suspend_point_1;
            case 2: goto suspend_point_2;
        }

    initial_suspend:
        // initial_suspend() 返回 suspend_always,所以挂起
        suspend_index = 1;
        return;  // 挂起,控制权返回调用者

    suspend_point_1:
        std::cout << "步骤 1" << std::endl;
        // co_await std::suspend_always{};
        suspend_index = 2;
        return;  // 挂起

    suspend_point_2:
        std::cout << "步骤 2" << std::endl;
        // co_await std::suspend_always{};
        suspend_index = 3;
        return;  // 挂起

    // 下次 resume 时继续
        std::cout << "步骤 3" << std::endl;
        // return_void()
        // final_suspend()
    }
};
*/

void state_machine_demo() {
    Task task = my_coroutine();
    // 此时协程在 initial_suspend 处挂起

    std::cout << "=== 第一次 resume ===" << std::endl;
    task.resume();  // 执行到 "步骤 1",在挂起点 1 挂起

    std::cout << "=== 第二次 resume ===" << std::endl;
    task.resume();  // 执行到 "步骤 2",在挂起点 2 挂起

    std::cout << "=== 第三次 resume ===" << std::endl;
    task.resume();  // 执行到 "步骤 3",协程结束
}

// ============================
// 示例2:Generator(co_yield 的状态机)
// ============================

template<typename T>
struct Generator {
    struct promise_type {
        T current_value;

        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 {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }

        // co_yield 转换为 co_await promise.yield_value(expr)
        std::suspend_always yield_value(T value) {
            current_value = value;
            return {};  // 每次 yield 都挂起
        }
    };

    std::coroutine_handle<promise_type> handle;

    explicit Generator(std::coroutine_handle<promise_type> h) : handle(h) {}
    ~Generator() { if (handle) handle.destroy(); }

    Generator(const Generator&) = delete;
    Generator(Generator&& other) noexcept : handle(other.handle) {
        other.handle = nullptr;
    }

    // 迭代器接口
    bool next() {
        handle.resume();
        return !handle.done();
    }

    T value() const {
        return handle.promise().current_value;
    }
};

// co_yield 的转换过程:
// co_yield expr; 等价于 co_await promise.yield_value(expr);
Generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;          // 挂起,返回当前值
        int next = a + b;    // 恢复后从这里继续
        a = b;
        b = next;
    }
}

/*
编译器转换后的状态机(伪代码):

struct fibonacci_frame {
    promise_type promise;
    int suspend_index = 0;
    int a, b, next;  // 局部变量保存在帧中

    void resume() {
        switch (suspend_index) {
            case 0: goto initial;
            case 1: goto after_yield;
        }

    initial:
        a = 0; b = 1;

    loop_start:
        promise.current_value = a;  // yield_value(a)
        suspend_index = 1;
        return;  // 挂起

    after_yield:
        next = a + b;
        a = b;
        b = next;
        goto loop_start;
    }
};
*/

void generator_demo() {
    auto gen = fibonacci();
    for (int i = 0; i < 10; i++) {
        gen.next();
        std::cout << gen.value() << " ";
    }
    std::cout << std::endl;
    // 输出: 0 1 1 2 3 5 8 13 21 34
}

// ============================
// 示例3:co_await 的展开过程
// ============================

/*
co_await expr 的展开步骤:

1. 获取 awaiter 对象
   auto&& awaiter = get_awaiter(expr);

2. 调用 await_ready()
   if (!awaiter.await_ready()) {
       // 需要挂起
       // 保存状态到协程帧
       // 调用 await_suspend(handle)
       auto result = awaiter.await_suspend(handle);
       // 根据 result 决定:
       //   void: 挂起,返回调用者
       //   bool: true 挂起,false 立即恢复
       //   coroutine_handle: 挂起,恢复指定的协程
   }

3. 恢复后,调用 await_resume() 获取结果
   auto value = awaiter.await_resume();
*/

// 自定义 awaiter 示例
struct TimerAwaiter {
    int delay_ms;

    // 是否可以不挂起直接继续
    bool await_ready() const noexcept {
        return delay_ms <= 0;  // 如果延迟为 0,不需要挂起
    }

    // 挂起时执行的操作
    void await_suspend(std::coroutine_handle<> handle) const {
        // 实际场景中这里会注册定时器
        // 定时器到期后调用 handle.resume()
        std::cout << "挂起,等待 " << delay_ms << "ms" << std::endl;
        // 这里简化处理,直接恢复
        handle.resume();
    }

    // 恢复后获取结果
    int await_resume() const noexcept {
        return delay_ms;  // 返回等待的时间
    }
};

Task timer_coroutine() {
    std::cout << "开始" << std::endl;
    int waited = co_await TimerAwaiter{100};
    std::cout << "等待了 " << waited << "ms" << std::endl;
    co_await TimerAwaiter{0};  // await_ready 返回 true,不挂起
    std::cout << "结束" << std::endl;
}

int main() {
    std::cout << "=== 状态机演示 ===" << std::endl;
    state_machine_demo();

    std::cout << "\n=== Generator 演示 ===" << std::endl;
    generator_demo();

    return 0;
}

协程帧的内存布局 ​

内容说明
resume 函数指针指向恢复函数
destroy 函数指针指向销毁函数
promise 对象用户定义的 promise_type 实例
挂起点索引记录当前挂起在哪个点
局部变量跨挂起点存活的局部变量
临时对象co_await 表达式中的临时对象

常见问题 ​

协程帧为什么要堆分配?

因为协程的生命周期可能超过创建它的函数作用域。栈帧在函数返回时销毁,但协程可能还需要恢复。堆分配让协程帧独立于调用栈存在。编译器在某些情况下可以做"堆分配省略"(HALO),把协程帧放在调用者的栈上。

co_yield 和 co_await 是什么关系?

co_yield expr 是 co_await promise.yield_value(expr) 的语法糖。yield_value 返回一个 awaiter,控制挂起行为。

协程的挂起和恢复是怎么实现的?

编译器把协程函数转换为一个状态机。每个挂起点有一个编号,恢复时通过 switch 跳转到对应位置。局部变量保存在堆分配的协程帧中,不受栈帧销毁的影响。

适用场景 ​

  • 异步 I/O(网络、文件)
  • 惰性生成器(按需产生值)
  • 事件驱动编程
  • 任务调度系统

注意事项 ​

  • 协程帧通常堆分配,有一定开销
  • 跨挂起点的局部变量存在协程帧中,不跨挂起点的可以优化到栈上
  • final_suspend 必须是 noexcept
  • 协程销毁前要确保已经完成或者手动 destroy
  • 不要在协程中持有栈上的引用并跨越挂起点

总结 ​

编译器将协程函数转换为状态机:每个挂起点对应一个状态,局部变量保存在堆分配的协程帧中。co_await 展开为 await_ready/await_suspend/await_resume 三步,co_yield 是 co_await 的语法糖。面试中要能解释协程帧的结构(函数指针 + promise + 挂起索引 + 局部变量)、状态机的跳转逻辑、以及 co_await 的展开过程。