C++ 协程与异常处理：协程中的异常传播机制

各位听众，欢迎来到今天的 C++ 协程与异常处理主题讲座！今天咱们聊聊协程这玩意儿，尤其是它跟异常处理搅和在一起时，会碰撞出什么样的火花。

什么是协程？别跟我拽那些官方定义！

你可能听过协程，但那些生涩的定义听着就想睡觉。简单来说，协程就像一个“暂停”按钮。普通的函数，一旦开始执行，就得一口气跑完。但协程不一样，它可以执行到一半，然后说：“嘿，哥们，我先歇会儿，等会儿再回来继续。”

这种“暂停和恢复”的能力，让协程在处理异步操作、并发任务等方面非常有用。想象一下，你要处理大量的网络请求，如果每个请求都用一个线程，资源消耗太大。协程就能优雅地解决这个问题，它可以暂停等待网络数据，然后回来继续处理，而不需要创建新的线程。

C++ 协程：Promise, Awaiter, Coroutine Handle，三大金刚

C++20 引入了协程，它不是语言内置的魔法，而是通过一些特殊的类型和操作符来实现的。理解这三个概念是掌握 C++ 协程的关键：

Promise (承诺体): 这是协程的“管家”，负责协程的状态管理，比如结果、异常，以及协程的生命周期。你可以把它看作是协程的“大脑”。
Awaiter (等待器): 这是协程的“暂停”按钮。当协程遇到 co_await 表达式时，Awaiter 就会被调用。Awaiter 决定是否暂停协程，以及在恢复时做什么。
Coroutine Handle (协程句柄): 这是协程的“遥控器”，你可以通过它来控制协程的恢复、销毁等操作。

异常处理：程序猿的救命稻草

异常处理是编程中的一种错误处理机制，它允许程序在遇到错误时，不至于崩溃，而是能够优雅地处理错误，并继续执行。C++ 中的异常处理使用 try, catch, throw 关键字。

try: 包裹可能抛出异常的代码块。
catch: 用于捕获特定类型的异常，并执行相应的处理代码。
throw: 用于抛出异常。

协程中的异常传播：一场惊心动魄的旅程

现在，让我们把协程和异常处理放在一起。协程中的异常传播，可比普通函数复杂多了。因为协程可以暂停和恢复，异常需要在不同的“暂停点”之间传递。

基本原则：异常必须被处理

无论是在普通函数还是协程中，一个基本的原则是：未处理的异常会导致程序崩溃！ 所以，我们必须确保所有可能抛出的异常都被捕获和处理。

协程内的异常：Promise 的责任

如果在协程内部抛出了异常，并且没有被协程内部的 try...catch 块捕获，那么这个异常会被传递到协程的 Promise 对象。Promise 对象会调用 set_exception() 方法来记录这个异常。

set_exception() 方法的两种常见实现：

std::exception_ptr: Promise 可以存储一个 std::exception_ptr，然后在协程恢复时，重新抛出这个异常。
std::terminate(): Promise 可以直接调用 std::terminate() 来终止程序。这通常用于处理严重的、无法恢复的错误。

示例代码：协程内部抛出异常

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

struct MyCoroutine {
    struct promise_type {
        int value;

        MyCoroutine get_return_object() { return MyCoroutine{std::coroutine_handle<promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {
            std::cerr << "Unhandled exception in coroutine!" << std::endl;
            std::terminate(); // 或者存储异常，并在 get_return_object() 恢复后抛出
        }
        void return_void() {}
    };

    std::coroutine_handle<promise_type> handle;
};

MyCoroutine my_coroutine() {
    std::cout << "Coroutine started" << std::endl;
    throw std::runtime_error("Something went wrong inside the coroutine!");
    std::cout << "Coroutine finished (this won't be printed)" << std::endl;
    co_return;
}

int main() {
    try {
        auto coro = my_coroutine();
        coro.handle.destroy(); // Important: Destroy the coroutine when done
    } catch (const std::exception& e) {
        std::cerr << "Exception caught in main: " << e.what() << std::endl;
    }

    return 0;
}

在这个例子中，my_coroutine() 函数内部抛出了一个 std::runtime_error 异常。由于协程内部没有 try...catch 块，这个异常会被传递到 Promise 对象的 unhandled_exception() 方法。unhandled_exception() 方法会打印错误信息，并调用 std::terminate() 终止程序。

重要提示： 如果你希望在协程外部捕获这个异常，你需要修改 Promise 的实现，将异常存储起来，然后在 get_return_object() 方法中重新抛出。

co_await 表达式中的异常：Awaiter 的介入

co_await 表达式是协程暂停和恢复的关键。如果在 co_await 表达式的 Awaiter 中抛出了异常，情况会更加复杂。Awaiter 负责处理异常，并将异常传递回协程。

Awaiter 的 await_resume() 方法:

Awaiter 有一个 await_resume() 方法，它在协程恢复时被调用。如果 await_resume() 方法抛出了异常，这个异常会直接传递到协程，就像在协程内部抛出异常一样。

示例代码：Awaiter 中抛出异常

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

struct MyAwaitable {
    bool await_ready() { return false; }
    void await_suspend(std::coroutine_handle<> h) {
        // Simulate some asynchronous operation
        std::cout << "Suspending..." << std::endl;
        h.resume(); // Resume immediately for simplicity
    }
    int await_resume() {
        std::cout << "Resuming..." << std::endl;
        throw std::runtime_error("Something went wrong in await_resume!");
        return 42;
    }
};

struct MyCoroutine {
    struct promise_type {
        int value;

        MyCoroutine get_return_object() { return MyCoroutine{std::coroutine_handle<promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() noexcept { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {
            std::cerr << "Unhandled exception in coroutine!" << std::endl;
            std::terminate(); // Or store the exception
        }
        void return_value(int v) { value = v; }
    };

    std::coroutine_handle<promise_type> handle;
};

MyCoroutine my_coroutine() {
    std::cout << "Coroutine started" << std::endl;
    try {
        int result = co_await MyAwaitable{};
        std::cout << "Result: " << result << std::endl; // This won't be printed
    } catch (const std::exception& e) {
        std::cerr << "Exception caught in coroutine: " << e.what() << std::endl;
    }
    std::cout << "Coroutine finished" << std::endl;
    co_return;
}

int main() {
    auto coro = my_coroutine();
    coro.handle.destroy();
    return 0;
}

在这个例子中，MyAwaitable::await_resume() 方法抛出了一个 std::runtime_error 异常。这个异常会被 my_coroutine() 函数中的 try...catch 块捕获。

co_return 语句中的异常：最后的挣扎

如果在 co_return 语句执行期间抛出了异常（例如，在 Promise 的 return_value() 或 return_void() 方法中），这个异常会传递到 promise.unhandled_exception()。这意味着，即使协程已经执行到最后，仍然有可能因为异常而终止。

异常处理的最佳实践：防患于未然

使用 try...catch 块: 在协程内部，使用 try...catch 块来捕获和处理可能抛出的异常。
自定义 Promise 类型: 实现自定义的 Promise 类型，并重写 unhandled_exception() 方法，以便更好地处理未处理的异常。
Awaiter 的异常处理: 在 Awaiter 的 await_resume() 方法中，也要考虑异常处理，避免异常被忽略。
RAII 思想: 使用 RAII (Resource Acquisition Is Initialization) 思想，确保在异常发生时，资源能够被正确释放。

协程异常处理：总结与思考

协程中的异常处理是一个复杂但重要的主题。理解异常的传播机制，并采取适当的措施，可以确保你的协程程序更加健壮和可靠。

总结表格：异常处理的关键点

发生异常的位置	处理方式
协程内部	使用 `try...catch` 块捕获异常。如果未捕获，异常会传递到 Promise 的 `unhandled_exception()` 方法。
`co_await` 表达式	异常可能在 Awaiter 的 `await_ready()`, `await_suspend()`, `await_resume()` 方法中抛出。`await_resume()` 抛出的异常会直接传递到协程。
`co_return` 语句	异常可能在 Promise 的 `return_value()` 或 `return_void()` 方法中抛出。这些异常会传递到 `promise.unhandled_exception()`。
Promise 的 `unhandled_exception()`	默认行为是调用 `std::terminate()`。建议自定义 Promise 类型，并重写 `unhandled_exception()` 方法，以便更好地处理异常 (例如记录日志、重新抛出异常等)。

最后的思考：

协程的出现，让我们的代码更加灵活和高效。但是，也带来了新的挑战，比如异常处理。我们需要不断学习和实践，才能掌握协程的精髓，写出高质量的 C++ 代码。

今天就到这里，谢谢大家！希望大家对协程异常处理有了更清晰的认识。记住，异常处理是程序健壮性的重要保障，不要掉以轻心！

发表回复 取消回复

发表回复取消回复