无栈协程特性与限制 ​

什么是无栈协程 ​

C++20 的协程是无栈协程(Stackless Coroutine)。"无栈"指的是协程挂起时不保留完整的调用栈,而是把需要跨挂起点保留的局部变量存储在堆上分配的协程帧(Coroutine Frame)中。协程恢复时从协程帧中恢复状态,继续在调用者的栈上执行。

与之对应的是有栈协程(Stackful Coroutine),比如 Boost.Coroutine2 和 Boost.Fiber,它们为每个协程分配一个独立的栈空间,可以在调用栈的任意深度挂起。

无栈 vs 有栈协程 ​

特性无栈协程(C++20)有栈协程(Boost.Fiber 等)
挂起位置只能在协程函数自身内部挂起可以在调用栈的任意深度挂起
状态存储协程帧(堆上,编译器管理)独立栈空间(预分配)
内存开销很小(只存需要的变量,通常几十到几百字节)较大(需要预分配栈,通常几十 KB 到几 MB)
切换开销极小(函数调用级别)较小但比无栈大(需要切换栈指针)
编译器优化可以内联和优化(HALO)难以跨协程优化
传染性有(调用链上层也要改成协程)无(普通函数也能挂起)
标准支持C++20 标准第三方库

无栈协程的核心特性 ​

编译器驱动的状态机转换 ​

编译器把协程函数转换成一个状态机。每个 co_await、co_yield 是一个状态转换点。局部变量中只有跨挂起点存活的变量会被保存到协程帧中,其他变量仍然使用栈。

cpp
// 用户写的协程
Generator<int> example() {
    int a = 1;       // 跨挂起点,存入协程帧
    co_yield a;

    int b = 2;       // 跨挂起点,存入协程帧
    co_yield a + b;

    int c = 3;       // 不跨挂起点(之后没有挂起),可能留在栈上
}

// 编译器大致生成的状态机(伪代码)
void example_resume(CoroutineFrame* frame) {
    switch (frame->state) {
        case 0:
            frame->a = 1;
            frame->state = 1;
            return;  // 挂起
        case 1:
            frame->b = 2;
            frame->state = 2;
            return;  // 挂起
        case 2:
            // c = 3 不需要保存
            frame->state = 3;  // 完成
            return;
    }
}

堆分配消除(HALO) ​

HALO(Heap Allocation eLision Optimization)是编译器的一种优化:当编译器能证明协程帧的生命周期完全嵌套在调用者的栈帧中时,可以把协程帧分配在栈上而不是堆上,完全消除动态内存分配。

HALO 生效的条件:

  • 协程的创建和销毁在同一个函数中
  • 编译器能内联协程的 ramp 函数(初始化部分)
  • 编译器能看到协程帧不会逃逸出当前作用域
cpp
// HALO 可能生效的场景
void process() {
    auto gen = range(1, 10);    // 创建
    while (gen.next()) {        // 使用
        std::cout << gen.value();
    }
    // gen 析构,协程帧销毁   // 销毁在同一函数
}

// HALO 不太可能生效的场景
Generator<int> create_generator() {
    return range(1, 10);        // 协程帧逃逸出函数
}

自定义内存分配 ​

可以在 promise_type 中重载 operator new 和 operator delete 来控制协程帧的分配策略:

cpp
#include <coroutine>
#include <iostream>
#include <cstdlib>

struct PoolTask {
    struct promise_type {
        PoolTask get_return_object() {
            return PoolTask{
                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(); }

        // 自定义协程帧分配
        static void* operator new(std::size_t size) {
            std::cout << "分配协程帧: " << size << " 字节" << std::endl;
            return std::malloc(size);
        }

        static void operator delete(void* ptr, std::size_t size) {
            std::cout << "释放协程帧: " << size << " 字节" << std::endl;
            std::free(ptr);
        }
    };

    std::coroutine_handle<promise_type> handle_;
    explicit PoolTask(std::coroutine_handle<promise_type> h) : handle_(h) {}
    ~PoolTask() { if (handle_) handle_.destroy(); }
    PoolTask(const PoolTask&) = delete;
    PoolTask& operator=(const PoolTask&) = delete;
    PoolTask(PoolTask&& o) noexcept : handle_(o.handle_) { o.handle_ = nullptr; }

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

PoolTask pool_coroutine() {
    std::cout << "协程执行中" << std::endl;
    co_return;
}

void allocation_demo() {
    auto task = pool_coroutine();  // 输出分配信息
    task.resume();
    // 析构时输出释放信息
}

无栈协程的限制 ​

不能在子函数中挂起 ​

这是无栈协程最大的限制。co_await、co_yield、co_return 只能出现在协程函数自身的函数体中,不能出现在协程调用的普通函数中。

cpp
// 错误:不能在子函数中使用 co_await
void helper() {
    co_await std::suspend_always{};  // 编译错误:helper 不是协程
}

Task my_coroutine() {
    helper();  // helper 中不能挂起
    co_return;
}

// 正确做法:把子函数也改成协程
Task helper_coroutine() {
    co_await std::suspend_always{};  // 可以
    co_return;
}

Task my_coroutine() {
    co_await helper_coroutine();  // 等待子协程完成
    co_return;
}

这种特性被称为"传染性"——一旦某个函数需要挂起,它自身和调用链上的所有函数都可能需要变成协程。

语法限制 ​

限制说明
不能用 return协程中必须用 co_return
不能用可变参数void f(int, ...) 不能是协程
不能是 constexpr / consteval协程不能在编译期求值
不能是构造函数/析构函数构造函数和析构函数不能是协程
不能是 main 函数main 不能是协程
不能用占位符返回类型推导auto f() { co_return 1; } 在某些情况下不合法

协程帧的堆分配 ​

默认情况下,每次调用协程函数都会在堆上分配一个协程帧。虽然 HALO 优化可以在某些情况下消除堆分配,但这不是标准保证的——完全取决于编译器实现和优化级别。在 debug 模式下,HALO 几乎不会生效。

没有标准的高层工具 ​

C++20 只提供了协程的底层机制(coroutine_handle、coroutine_traits、suspend_always/suspend_never),没有提供现成的 Task、Generator 等工具类型。开发者需要自己实现或依赖第三方库。C++23 引入了 std::generator,但 Task 类型到 C++26 仍在提案中。

调试困难 ​

协程的状态机转换是编译器生成的,调试时难以跟踪协程的执行流程。断点、单步执行等调试手段在协程的挂起/恢复点附近可能表现不直观。

基本示例 ​

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

// ============================
// 演示传染性问题及解决方案
// ============================

// 基础 Task 类型
struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{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 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&& o) noexcept : handle_(o.handle_) { o.handle_ = nullptr; }

    void resume() { if (handle_ && !handle_.done()) handle_.resume(); }
    bool done() const { return !handle_ || handle_.done(); }

    // 让 Task 可以被 co_await
    bool await_ready() const noexcept { return false; }
    void await_suspend(std::coroutine_handle<> caller) {
        handle_.resume();  // 简化实现:直接运行子协程到完成
    }
    void await_resume() const noexcept {}
};

// 传染性示例:底层操作需要异步 → 所有调用者都变成协程
Task low_level_io() {
    std::cout << "  底层 I/O 操作" << std::endl;
    co_await std::suspend_always{};  // 模拟异步等待
    std::cout << "  I/O 完成" << std::endl;
}

Task mid_level_process() {
    std::cout << "中间层处理开始" << std::endl;
    co_await low_level_io();  // 必须也是协程才能等待子协程
    std::cout << "中间层处理结束" << std::endl;
}

Task high_level_action() {
    std::cout << "高层操作开始" << std::endl;
    co_await mid_level_process();  // 同样必须是协程
    std::cout << "高层操作结束" << std::endl;
}

void infection_demo() {
    auto task = high_level_action();
    // 需要反复 resume 来驱动整个链条
    while (!task.done()) {
        task.resume();
    }
}

// ============================
// 演示协程帧大小的影响因素
// ============================

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() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        std::suspend_always yield_value(T value) {
            current_value = std::move(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&& o) noexcept : handle_(o.handle_) { o.handle_ = nullptr; }

    bool next() {
        if (handle_ && !handle_.done()) { handle_.resume(); return !handle_.done(); }
        return false;
    }
    const T& value() const { return handle_.promise().current_value; }
};

// 协程帧小:只有少量局部变量跨挂起点
Generator<int> small_frame() {
    int i = 0;
    while (true) {
        co_yield i++;
    }
}

// 协程帧大:大量局部变量跨挂起点
Generator<int> large_frame() {
    int a[100] = {};  // 400 字节的数组需要保存到协程帧
    int index = 0;
    for (int i = 0; i < 100; ++i) {
        a[i] = i * i;
    }
    while (index < 100) {
        co_yield a[index++];
    }
}

void frame_size_demo() {
    // 小帧协程
    auto small = small_frame();
    for (int i = 0; i < 5 && small.next(); ++i) {
        std::cout << small.value() << " ";
    }
    std::cout << std::endl;

    // 大帧协程
    auto large = large_frame();
    for (int i = 0; i < 5 && large.next(); ++i) {
        std::cout << large.value() << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::cout << "=== 传染性演示 ===" << std::endl;
    infection_demo();

    std::cout << "\n=== 协程帧大小 ===" << std::endl;
    frame_size_demo();

    return 0;
}

适用场景 ​

  • 异步 I/O(网络、文件、数据库查询)
  • 惰性序列生成(生成器模式)
  • 事件驱动编程(GUI、游戏循环)
  • 状态机实现(协议解析、工作流引擎)
  • 高并发服务器(用协程替代线程处理请求)

常见问题 ​

无栈协程适合所有异步场景吗?

不是。如果你的代码有很深的调用层次且底层需要异步,无栈协程的传染性会迫使你重写大量代码。有栈协程在这种场景下更方便——但它们不是标准的一部分。

HALO 优化可靠吗?

不完全可靠。HALO 是编译器的可选优化,标准不保证它一定生效。在 debug 模式下几乎不会触发。如果你对内存分配敏感,可以通过自定义 operator new 使用内存池。

C++20 协程和线程池怎么配合?

典型模式是:协程挂起时把 coroutine_handle 扔到线程池的任务队列中,线程池里的工作线程调用 handle.resume() 来恢复协程。协程本身不关心在哪个线程上执行。

为什么 C++20 不提供现成的 Task 类型?

C++20 的协程设计理念是"提供机制,不提供策略"。不同的应用场景对协程的行为有不同要求(惰性启动 vs 立即启动、单线程 vs 多线程、异常传播策略等),标准委员会选择先提供底层工具,让库作者和框架设计者来构建适合各自场景的高层类型。

注意事项 ​

  • 无栈协程只能在协程函数自身中挂起,不能在子函数中挂起
  • 协程帧默认在堆上分配,HALO 优化不是保证的
  • 协程的传染性会影响代码架构——设计时需要提前规划
  • debug 模式下协程性能可能比 release 差很多(HALO 不生效、没有内联)
  • 协程帧的大小取决于跨挂起点的局部变量数量和大小
  • 递归协程的每一层都会分配一个独立的协程帧
  • 标准没有提供现成的高层协程工具(C++23 才有 std::generator)

编译器支持情况 ​

编译器最低支持版本HALO 支持
GCC10.0有限
Clang14.0较好
MSVC19.28 (VS 2019 16.8)有限

总结 ​

C++20 的无栈协程通过编译器将协程函数转换为状态机,把跨挂起点的局部变量保存在堆上的协程帧中。相比有栈协程,无栈协程的内存开销更小(只保存必要的变量,而不是整个栈)、切换更快、编译器优化空间更大(HALO 可以消除堆分配)。但无栈协程也有明显的限制:只能在协程函数自身中挂起(不能在子函数中挂起),具有传染性(调用链上的函数都可能需要变成协程),不能用于构造函数/析构函数/main 函数,C++20 标准缺少高层工具类型。理解这些特性和限制,有助于在实际项目中做出合理的架构决策——什么时候用协程、什么时候用线程、什么时候用回调。