C++20协程自定义完全实践（从promise_type开始的高阶技巧）

第一章：C++20协程与promise_type核心概念

C++20引入了原生协程支持，为异步编程提供了语言层面的基础设施。协程的核心机制依赖于三个关键组件：`co_await`、`co_yield` 和 `co_return`，以及一个可定制的 `promise_type` 类型。当函数中使用了上述关键字之一时，编译器会将其转换为状态机，并通过 `promise_type` 管理协程的生命周期和行为。

协程的基本结构

每个协程返回类型必须包含一个嵌套的 `promise_type`，该类型决定了协程如何启动、暂停、返回值处理及最终销毁。编译器在协程初始化阶段会自动创建 `promise_type` 实例，并调用其特定成员函数。

• get_return_object()：创建并返回协程句柄
• initial_suspend()：决定协程是否立即开始执行或挂起
• final_suspend()：定义协程结束时的行为
• return_value(T) 或 return_void()：处理返回值
• unhandled_exception()：异常处理路径

promise_type 示例实现

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

上述代码定义了一个最简化的协程返回类型 `Task` 及其 `promise_type`。其中 `std::suspend_always` 表示协程在开始和结束时都会挂起，允许外部控制恢复时机。

协程执行流程控制

阶段	调用方法	作用
创建	get_return_object	生成协程返回对象
启动	initial_suspend	决定是否立即运行
结束	final_suspend	控制协程终止行为

通过自定义 `promise_type`，开发者可以精确控制协程的行为，实现延迟执行、链式调用或资源清理等高级模式。

第二章：promise_type基础结构与编译器交互机制

2.1 理解协程框架：compiler、promise、awaiter三者关系

在C++20协程中，编译器（compiler）、promise对象和awaiter三者协同工作以实现异步逻辑的挂起与恢复。

核心组件职责

• Compiler：识别协程关键字（如co_await），生成状态机代码
• Promise：定义协程行为接口，控制结果返回与异常处理
• Awaiter：决定是否挂起、恢复及返回值类型

执行流程示例

suspend_always await_ready() { return false; }
void await_suspend(coroutine_handle<> h) { /* 恢复目标 */ }
int await_resume() { return 42; }

上述awaiter使协程始终挂起，await_suspend传入handle用于后续恢复，await_resume定义恢复后返回值。

组件	输入	输出
Compiler	co_await expr	调用expr.operator co_await()
Promise	get_return_object()	构造协程返回值
Awaiter	await_ready	决定是否同步执行

2.2 promise_type必需成员函数的语义与实现

在C++协程中，promise_type是协程行为控制的核心。它必须提供若干特定成员函数以满足编译器生成代码的调用需求。

必需成员函数列表

• get_return_object()：创建并返回协程句柄
• initial_suspend()：决定协程启动时是否挂起
• final_suspend()：定义协程结束时的挂起策略
• unhandled_exception()：异常处理机制
• 至少一个return_value或return_void

典型实现示例

struct promise_type {
    handle_type get_return_object() { 
        return handle_type::from_promise(*this); 
    }
    std::suspend_always initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void unhandled_exception() { std::terminate(); }
    void return_void() {}
};

上述代码定义了一个基础promise_type，其中initial_suspend和final_suspend均挂起，可用于延迟执行或资源清理。

2.3 协程句柄与返回对象的构造时机分析

在协程执行模型中，协程句柄（Coroutine Handle）是控制协程生命周期的关键对象。其构造发生在协程函数被调用时，编译器生成的Promise对象初始化后立即创建。

构造流程解析

• 调用协程函数时，首先分配Promise对象
• Promise通过get_return_object()构造返回值
• 随后创建协程句柄，绑定Promise与协程帧

task<int> compute() {
    co_return 42;
}

上述代码中，compute()调用触发task<int>的get_return_object()，返回未完成的task实例，此时句柄已关联运行上下文。

对象生命周期关系

阶段	Promise状态	句柄可用性
函数调用	已构造	可获取
首次暂停	挂起	有效
完成	析构中	失效

2.4 自定义返回类型与promise_type的绑定方式

在C++20协程中，自定义返回类型需通过`promise_type`进行绑定。编译器会查找返回类型的内部嵌套类`promise_type`，并据此生成协程帧的管理逻辑。

绑定机制解析

当协程函数返回自定义类型`Task`时，该类型必须内嵌`promise_type`：

struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

上述代码中，`get_return_object()`用于构造返回实例，`initial_suspend`控制协程启动时是否挂起。

关键成员函数作用

• get_return_object：生成协程返回值
• initial_suspend：决定协程开始是否立即执行
• final_suspend：控制协程结束时的行为
• return_void/return_value：处理无返回或有值返回情况

2.5 编译器如何生成协程状态机代码探秘

编译器在遇到协程函数时，会将其转换为一个状态机类，通过状态迁移控制执行流程。每个 `await` 点被标记为暂停点，对应状态机中的一个状态。

状态机结构解析

以 C# 为例，编译器生成的类包含：

• MoveNext()：驱动状态转移
• StateMachineAttribute：标记协程状态机
• 局部变量提升为字段

代码生成示例

// 原始协程
async Task DelayThenPrint()
{
    await Task.Delay(1000);
    Console.WriteLine("Done");
}

编译器将其重写为包含状态字段和 MoveNext 方法的状态机类型，await 表达式被拆解为任务注册与回调调度，实现非阻塞等待。

第三章：构建可复用的协程任务类型

3.1 设计一个支持co_await的task<>模板类

为了实现协程中可等待的 task 类型，必须定义符合 Awaitable 概念的类模板。核心是提供 await_ready、await_suspend 和 await_resume 三个方法。

关键接口设计

template<typename T>
class task {
public:
    struct promise_type;
    using handle_type = std::coroutine_handle<promise_type>;

    bool await_ready() const noexcept { return !handle || handle.done(); }
    void await_suspend(handle_type h) { /* 挂起逻辑 */ }
    T await_resume() { return handle.promise().result(); }
};

该代码定义了 task 的基本结构。其中 promise_type 负责管理协程状态，await_suspend 决定是否继续执行或挂起，await_resume 返回最终结果。

状态管理机制

• 协程句柄（coroutine_handle）用于控制执行流程
• promise_type 存储返回值与异常
• 通过引用计数或事件循环调度生命周期

3.2 在promise_type中管理异常与最终完成回调

在协程的生命周期中，`promise_type` 扮演着控制执行结果与异常处理的核心角色。通过重写 `unhandled_exception()` 方法，可捕获协程内部未处理的异常并存储，供后续检查。

异常捕获机制

void unhandled_exception() {
    exception_ = std::current_exception();
}

当协程体抛出异常时，运行时自动调用此方法，将异常对象保存在成员变量 `exception_` 中，避免程序崩溃。

最终完成回调的实现

通过 `final_suspend()` 控制协程结束时的行为：

auto final_suspend() noexcept {
    struct awaiter {
        bool await_ready() { return false; }
        void await_resume() {}
        void await_suspend(std::coroutine_handle<>) {
            // 触发完成回调逻辑
        }
    };
    return awaiter{};
}

该挂起点允许在协程销毁前执行清理或通知操作，如唤醒等待线程或触发回调函数，确保资源安全释放与状态同步。

3.3 实现惰性执行与即时执行协程的行为区分

在现代异步编程中，协程的执行策略直接影响系统资源利用率和响应性能。根据调用时机的不同，协程可分为惰性执行与即时执行两种模式。

惰性执行协程

惰性执行的协程仅在被显式等待时才启动，适用于按需计算场景：

func lazyCoroutine() <-chan int {
    ch := make(chan int)
    go func() {
        defer close(ch)
        time.Sleep(1 * time.Second)
        ch <- 42
    }()
    return ch // 启动后不立即执行核心逻辑
}

该模式延迟资源消耗，适合高并发下减少调度压力。

即时执行协程

即时执行协程在创建时即开始运行，确保任务尽早处理：

func eagerCoroutine() {
    go func() {
        time.Sleep(500 * time.Millisecond)
        fmt.Println("Task completed")
    }() // 立即触发goroutine执行
}

特性	惰性执行	即时执行
启动时机	首次await	创建时
资源占用	低	高
响应延迟	较高	较低

第四章：高阶技巧与性能优化策略

4.1 自定义内存分配：重载operator new/delete for coroutine

在协程频繁创建与销毁的场景中，标准内存分配可能成为性能瓶颈。通过重载 `operator new` 和 `operator delete`，可为协程定制高效内存管理策略。

重载实现示例

void* operator new(std::size_t size) {
    return malloc(size ? size : 1);
}

void operator delete(void* ptr) noexcept {
    free(ptr);
}

上述代码拦截协程帧的内存请求，使用更轻量的分配器替代默认堆操作，减少系统调用开销。

性能优化优势

• 降低内存分配延迟，提升协程启动速度
• 支持对象池或区域分配（arena allocation）集成
• 便于内存使用监控与调试追踪

4.2 避免堆分配：使用coroutine_handle::from_promise栈优化

在C++协程中，编译器通常会将promise对象和协程帧（coroutine frame）在堆上分配，带来不必要的内存开销。通过`coroutine_handle::from_promise`，可实现栈优化，避免动态分配。

核心机制

利用promise类型反向构造句柄，允许在已知promise生命周期可控时，将其置于栈上。关键在于自定义`get_return_object`方法：

struct stack_promise {
    std::coroutine_handle<> get_return_object() {
        return std::coroutine_handle<stack_promise>::from_promise(*this);
    }
    std::suspend_always initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void return_void() {}
    void unhandled_exception() {}
};

上述代码中，`from_promise`直接从栈上`*this`构建句柄，绕过堆分配。该技术适用于栈生命周期明确的场景，显著降低协程启动开销。

4.3 协程取消机制的设计与promise_type集成

在协程设计中，取消机制是保障资源安全和响应性的关键。通过在 `promise_type` 中集成取消状态，可实现协程体内外的协同控制。

取消标志的集成

在自定义 `promise_type` 中添加布尔字段标记取消状态：

struct promise_type {
    bool canceled = false;
    void cancel() { canceled = true; }
    auto yield_value(std::nullptr_t) {
        return std::suspend_always{};
    }
};

该字段由外部调用 `cancel()` 设置，协程内部可通过轮询判断是否应提前终止。

协作式取消检测

协程函数在长时间操作中应周期性检查取消状态：

• 每次循环迭代时查询 `promise.canceled`
• 若为真，则清理资源并主动返回
• 确保不继续执行后续耗时逻辑

此方式实现了轻量级、协作式的取消协议，避免强制中断导致的状态不一致。

4.4 多线程环境下协程的调度与同步保障

在多线程环境中，协程的调度需兼顾线程安全与执行效率。运行时系统通常采用工作窃取（work-stealing）算法分配协程任务，确保各线程负载均衡。

调度机制

每个线程维护本地任务队列，协程优先在同一线程内切换，减少锁竞争。当本地队列为空时，线程会从其他线程队列尾部“窃取”任务。

同步保障

使用原子操作和无锁队列管理协程状态变更。以下为Golang中通过sync.Mutex保护共享数据的示例：

var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    defer mu.Unlock()
    counter++ // 安全更新共享变量
}

该代码确保多个协程并发调用increment时，counter的修改具有原子性，避免数据竞争。

第五章：总结与现代C++异步编程展望

异步编程模型的演进趋势

现代C++标准持续推进异步编程能力的发展。从C++11引入的std::future，到C++20中协程（coroutines）和std::jthread的加入，异步任务管理变得更加高效和直观。

• 基于回调的传统模式逐渐被结构化并发替代
• 协程使异步代码具备同步书写风格，提升可读性
• std::lazy<T>提案预示更灵活的延迟计算支持

实战案例：协程结合线程池优化I/O密集型服务

在高并发日志聚合系统中，采用自定义awaitable对象与静态线程池结合，显著降低上下文切换开销：

// 自定义任务类型，支持co_await
struct async_write_op {
    bool await_ready() { return false; }
    void await_suspend(std::coroutine_handle<> h) {
        thread_pool.post([h](){ h.resume(); }); // 写入完成后恢复协程
    }
    void await_resume() {}
};

未来技术整合方向

技术特性	当前状态	应用场景
C++23 std::sync_stream	已支持	多线程输出同步
Networking TS	草案阶段	原生异步网络通信

[主线程] → 启动协程任务 → [挂起] ↓ [线程池调度] → 执行I/O操作 → [完成通知] → [恢复执行]