协程基础概念与执行模型 ​

什么是协程 ​

协程(Coroutine)是一种可以暂停执行、稍后恢复的函数。普通函数从头执行到尾,中间不能停下来;协程可以在执行过程中"挂起"自己,把控制权交还给调用者,调用者在合适的时候再"恢复"协程,让它从上次挂起的地方继续执行。

C++20 引入的协程是无栈协程(Stackless Coroutine)——协程挂起时不保留调用栈,而是把局部变量保存在堆上分配的协程帧(Coroutine Frame)中。这和有栈协程(如 Boost.Fiber)不同,无栈协程的开销更小,但只能在协程函数自身内部挂起,不能在它调用的子函数中挂起。

协程的三个关键字 ​

C++20 用三个新关键字来标识协程操作:

关键字作用典型用途
co_await挂起协程,等待某个操作完成异步 I/O、等待事件
co_yield挂起协程并产出一个值给调用者生成器、惰性序列
co_return结束协程并返回最终值返回计算结果

只要一个函数体内出现了这三个关键字中的任何一个,编译器就把它当作协程处理。

协程的核心组件 ​

协程涉及三个核心对象,它们各自的职责不同:

调用者 <---> 返回对象(Return Object)
                |
                v
          协程句柄(coroutine_handle)
                |
                v
          承诺对象(promise_type)
                |
                v
          协程帧(Coroutine Frame,堆上分配)
                |
                v
          协程函数体(用户代码)
组件类型谁管理作用
承诺对象(Promise)用户定义的 promise_type编译器创建,用户定义行为控制协程的启动、挂起、结束行为
协程句柄(Handle)std::coroutine_handle<promise_type>用户通过返回对象间接持有恢复或销毁协程
返回对象(Return Object)用户定义的类型调用者持有对外提供访问协程结果的接口
协程帧(Frame)编译器内部编译器分配,用户通过句柄销毁存储局部变量、承诺对象、挂起点

协程的执行流程 ​

调用协程函数
    |
    v
分配协程帧(堆上)
    |
    v
构造承诺对象(promise_type)
    |
    v
调用 promise.get_return_object() → 创建返回对象
    |
    v
co_await promise.initial_suspend()
    |
    +--- suspend_always → 协程挂起,返回对象给调用者(惰性启动)
    +--- suspend_never  → 继续执行协程体
    |
    v
执行协程体 {
    遇到 co_await expr → 可能挂起
    遇到 co_yield expr → 调用 promise.yield_value(expr),然后挂起
    遇到 co_return expr → 调用 promise.return_value(expr),然后进入最终挂起
    遇到 co_return;     → 调用 promise.return_void(),然后进入最终挂起
    异常抛出             → 调用 promise.unhandled_exception()
}
    |
    v
co_await promise.final_suspend() (最终挂起点)
    |
    +--- suspend_always → 协程挂起但不销毁(调用者负责销毁)
    +--- suspend_never  → 协程自动销毁帧

基本示例 ​

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

// ============================
// 示例1:最简单的协程——什么都不做
// ============================

// 返回对象类型
struct SimpleTask {
    // 承诺类型——协程的"控制面板"
    struct promise_type {
        // 创建返回对象
        SimpleTask get_return_object() {
            return SimpleTask{
                std::coroutine_handle<promise_type>::from_promise(*this)
            };
        }

        // 协程开始时挂起(惰性启动)
        std::suspend_always initial_suspend() noexcept { return {}; }

        // 协程结束时挂起(调用者负责销毁)
        std::suspend_always 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(const SimpleTask&) = delete;
    SimpleTask& operator=(const SimpleTask&) = delete;

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

    // 恢复协程执行
    void resume() {
        if (handle_ && !handle_.done()) {
            handle_.resume();
        }
    }

    // 检查协程是否已完成
    bool done() const {
        return !handle_ || handle_.done();
    }
};

// 协程函数——函数体中有 co_return,编译器把它当协程处理
SimpleTask simple_coroutine() {
    std::cout << "协程开始执行" << std::endl;
    co_return;  // 结束协程
}

void simple_demo() {
    std::cout << "创建协程" << std::endl;
    auto task = simple_coroutine();  // 创建协程,但因为 initial_suspend 返回 suspend_always,不会立即执行

    std::cout << "协程已创建但尚未执行" << std::endl;
    task.resume();  // 恢复执行,输出 "协程开始执行"

    std::cout << "协程已完成: " << std::boolalpha << task.done() << std::endl;
}

// ============================
// 示例2:简单生成器
// ============================

struct Generator {
    struct promise_type {
        int current_value;  // 当前产出的值

        Generator get_return_object() {
            return Generator{
                std::coroutine_handle<promise_type>::from_promise(*this)
            };
        }

        std::suspend_always initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }

        // co_yield 会调用这个方法
        std::suspend_always yield_value(int value) {
            current_value = value;  // 保存产出的值
            return {};              // 挂起协程
        }

        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    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& operator=(const Generator&) = delete;
    Generator(Generator&& other) noexcept : handle_(other.handle_) {
        other.handle_ = nullptr;
    }

    // 获取下一个值
    bool next() {
        if (handle_ && !handle_.done()) {
            handle_.resume();
            return !handle_.done();
        }
        return false;
    }

    // 获取当前值
    int value() const {
        return handle_.promise().current_value;
    }
};

// 生成器协程:产出 0 到 n-1 的整数序列
Generator range(int n) {
    for (int i = 0; i < n; ++i) {
        co_yield i;  // 产出一个值然后挂起
    }
    // 隐式 co_return;
}

// 斐波那契数列生成器
Generator fibonacci(int count) {
    int a = 0, b = 1;
    for (int i = 0; i < count; ++i) {
        co_yield a;       // 产出当前值
        int next = a + b; // 计算下一个值
        a = b;
        b = next;
    }
}

void generator_demo() {
    std::cout << "range(5): ";
    auto gen = range(5);
    while (gen.next()) {
        std::cout << gen.value() << " ";
    }
    std::cout << std::endl;

    std::cout << "fibonacci(8): ";
    auto fib = fibonacci(8);
    while (fib.next()) {
        std::cout << fib.value() << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例3:多次挂起和恢复
// ============================

SimpleTask multi_suspend() {
    std::cout << "步骤 1" << std::endl;
    co_await std::suspend_always{};  // 手动挂起

    std::cout << "步骤 2" << std::endl;
    co_await std::suspend_always{};  // 再次挂起

    std::cout << "步骤 3" << std::endl;
    // 隐式 co_return;
}

void multi_suspend_demo() {
    auto task = multi_suspend();

    std::cout << "--- resume 1 ---" << std::endl;
    task.resume();  // 执行步骤 1,然后挂起

    std::cout << "--- resume 2 ---" << std::endl;
    task.resume();  // 执行步骤 2,然后挂起

    std::cout << "--- resume 3 ---" << std::endl;
    task.resume();  // 执行步骤 3,然后结束
}

int main() {
    std::cout << "=== 简单协程 ===" << std::endl;
    simple_demo();

    std::cout << "\n=== 生成器 ===" << std::endl;
    generator_demo();

    std::cout << "\n=== 多次挂起 ===" << std::endl;
    multi_suspend_demo();

    return 0;
}

协程 vs 普通函数 vs 线程 ​

方面普通函数协程线程
执行方式一次性从头到尾可挂起和恢复并行执行
状态保存栈帧(函数返回即销毁)协程帧(堆上)独立栈
切换开销无很小(函数调用级别)较大(系统调用级别)
并发模型无协作式(主动让出)抢占式(OS 调度)
内存开销栈帧大小协程帧大小(通常很小)完整线程栈(默认 1-8 MB)

适用场景 ​

  • 异步 I/O:网络读写、文件操作等需要等待的场景
  • 生成器:惰性产出序列中的元素(斐波那契、文件行读取等)
  • 状态机:用顺序代码表达复杂的状态转换逻辑
  • 事件驱动编程:在事件循环中用协程替代回调
  • 流式处理:管道式的数据变换

常见问题 ​

C++20 协程开箱就能用吗?

不完全是。C++20 只提供了协程的底层机制(三个关键字、coroutine_handle、coroutine_traits、suspend_always/suspend_never),没有提供现成的 Task、Generator 等高层类型。你需要自己写返回对象和 promise_type,或者使用第三方库(如 cppcoro)。C++23 引入了 std::generator,算是标准库的第一个协程工具类型。

协程帧一定分配在堆上吗?

语义上是的。但编译器可以在确定协程的生命周期完全嵌套在调用者中时,将帧分配优化掉("Heap Allocation Elision",HALO)。是否真的优化取决于编译器实现。

协程可以递归调用自己吗?

可以,但要注意每次递归都会分配一个新的协程帧。如果递归很深,堆内存消耗会很大。

initial_suspend 返回 suspend_always 和 suspend_never 有什么区别?

suspend_always 表示协程创建后立即挂起(惰性启动),调用者需要手动 resume() 才开始执行。suspend_never 表示协程创建后立即开始执行,直到遇到第一个挂起点。惰性启动更常用,因为它让调用者完全控制执行时机。

注意事项 ​

  • 协程函数不能用 return,必须用 co_return
  • 协程不能是 constexpr、consteval 函数
  • 协程不能是构造函数、析构函数、main 函数
  • 协程不能使用可变参数(variadic arguments)
  • final_suspend() 必须是 noexcept 的
  • 协程句柄是非拥有的(non-owning),销毁责任需要明确
  • 恢复一个已完成的协程是未定义行为
  • 协程帧的生命周期管理是容易出错的地方,需要格外注意

编译器支持情况 ​

编译器最低支持版本头文件
GCC10.0<coroutine>
Clang14.0(完整支持)<coroutine>
MSVC19.28 (VS 2019 16.8)<coroutine>

总结 ​

C++20 协程是一种可以挂起和恢复的函数,通过 co_await、co_yield、co_return 三个关键字来标识挂起点和结束点。协程的执行由三个核心组件协调:承诺对象(promise_type)控制协程的生命周期行为,协程句柄(coroutine_handle)让外部代码恢复或销毁协程,返回对象是调用者拿到的接口。协程是无栈的,挂起时状态保存在堆上的协程帧中,切换开销比线程小得多。C++20 的协程设计偏底层——提供了机制但不提供策略,你需要自己定义 promise_type 和返回类型来控制协程的具体行为。