异常的连环接力：深度解析 C++20 协程多层嵌套下的异常冒泡机制与异步栈恢复艺术

在 C++20 协程中处理多层异常，本质上是利用promise作为中转站，将“异步的失败”转化为“同步的感知”。通过精心设计的Awaiter，我们可以让复杂的异步调用链拥有像同步代码一样直观的错误处理体验。你目前处理的业务场景中，异步调用的深度通常是多少层？如果深度超过 3 层，这种自动冒泡的Task模型将能为你节省大量的冗余代码。🤝。

prrxheuxbeu

549人浏览 · 2026-01-23 22:41:27

prrxheuxbeu · 2026-01-23 22:41:27 发布

🌊 异常的连环接力：深度解析 C++20 协程多层嵌套下的异常冒泡机制与异步栈恢复艺术 ⚡

📄 摘要 (Abstract)

当协程 A co_await 协程 B，而 B 又 co_await 协程 C 时，任何底层发生的异常都必须跨越多个挂起点安全地传递回最顶层的业务逻辑。本文将探讨“异步异常链”的构建，重点讲解如何通过 await_resume 实现异常的自动重抛，并展示在多级嵌套下如何利用 RAII 确保每一层协程帧（Coroutine Frame）在异常发生时都能正确清理，避免产生“僵尸协程”。

一、异常传递模型：异步世界的“多米诺骨牌” 🛡️

处理跨越多个 co_await 的异常，其核心思想是：将异常存储在底层协程的 promise 中，并在上层协程恢复执行的瞬间将其“激活”。

1.1 传递链路分解图 🗺️

阶段	参与者	动作说明
第一步：产生	底层协程 (Leaf)	抛出异常，进入 `unhandled_exception()` 存储 `exception_ptr`。
第二步：通知	句柄 (Handle)	底层协程执行完毕（处于 `final_suspend`），唤醒等待它的上层协程。
第三步：中继	包装类 (Awaiter)	上层协程在 `await_resume()` 中检查底层状态，发现异常并 `rethrow`。
第四步：捕获	顶层逻辑 (Root)	像对待普通同步异常一样，使用 `try-catch` 捕获。

二、实战模拟：构建“套娃式”异步异常传播系统

为了实现跨多个调用的异常处理，我们需要增强 Task 对象的 Awaiter 逻辑。

#include <iostream>
#include <coroutine>
#include <exception>

// 增强版 Task，支持异常自动冒泡
struct ChainTask {
    struct promise_type {
        std::exception_ptr exc_ptr;
        ChainTask get_return_object() { return {std::coroutine_handle<promise_type>::from_promise(*this)}; }
        std::initial_suspend initial_suspend() { return std::suspend_always{}; } // 延迟启动
        std::final_suspend final_suspend() noexcept { return std::suspend_always{}; }
        void return_void() {}
        void unhandled_exception() { exc_ptr = std::current_exception(); }
    };

    std::coroutine_handle<promise_type> handle;

    // Awaiter 接口：这是实现异常“接力”的关键
    auto operator co_await() {
        struct Awaiter {
            std::coroutine_handle<promise_type> h;
            bool await_ready() { return false; }
            void await_suspend(std::coroutine_handle<> caller) {
                h.resume(); // 启动/恢复子协程
                caller.resume(); // 简单演示：实际应由调度器管理
            }
            // 🌟 核心：上层协程通过 co_await 恢复时，此函数会被调用
            void await_resume() {
                if (h.promise().exc_ptr) {
                    std::rethrow_exception(h.promise().exc_ptr); // 向上传播！
                }
            }
        };
        return Awaiter{handle};
    }
};

// --- 多层嵌套函数 ---

ChainTask leaf_worker() {
    std::cout << " [Leaf] 正在执行底层操作..." << std::endl;
    throw std::runtime_error("底层硬件突发故障！💥");
    co_return;
}

ChainTask middle_manager() {
    std::cout << " [Middle] 准备调用底层..." << std::endl;
    co_await leaf_worker(); // 异常会在这里抛出，并被 middle 的编译器捕获
    std::cout << " [Middle] 这一行永远不会执行。" << std::endl;
}

int main() {
    auto root = middle_manager();
    try {
        // 启动顶层协程
        root.handle.resume(); 
        // 检查顶层是否有异常冒出
        if (root.handle.promise().exc_ptr) {
            std::rethrow_exception(root.handle.promise().exc_ptr);
        }
    } catch (const std::exception& e) {
        std::cerr << " [Main] 最终捕获全链路异常: " << e.what() << std::endl;
    }
    return 0;
}