C++协程在异步网络编程中的异常处理与资源管理-源码库

C++协程在异步网络编程中的异常处理与资源管理：从理论到实战的完整指南

作为一名长期深耕高性能网络编程的开发者，我见证了C++20协程从概念到落地的整个过程。在实际项目中，最让我头疼的不是协程的基本使用，而是异常处理和资源管理这两个”隐形杀手”。今天，我将分享在异步网络编程中处理协程异常和资源管理的实战经验，希望能帮你避开我踩过的那些坑。

协程异常处理的基础概念

在传统同步代码中，异常处理相对直观：try-catch块就能解决大部分问题。但在协程的异步世界里，异常传播变得复杂得多。协程可以在挂起时抛出异常，而调用者可能在不同的执行上下文中。

让我先展示一个基础的协程异常处理示例：


#include 
#include 
#include 

struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {
            // 捕获协程内部未处理的异常
            std::rethrow_exception(std::current_exception());
        }
        void return_void() {}
    };

    std::coroutine_handle handle;
    
    void resume() {
        if (handle && !handle.done()) {
            handle.resume();
        }
    }
    
    ~Task() {
        if (handle) handle.destroy();
    }
};

Task async_operation() {
    co_await std::suspend_always{};
    throw std::runtime_error("模拟网络操作失败");
}

在这个例子中，unhandled_exception 是协程 promise 类型的关键成员函数，负责处理协程内部抛出的未处理异常。在实际网络编程中，我们需要更精细地控制异常传播。

网络协程中的异常安全设计

在网络编程中，资源泄漏是最常见的问题之一。让我分享一个连接管理的实战案例：


#include 
#include 

class NetworkConnection {
private:
    int socket_fd;
    bool connected = false;
    
public:
    NetworkConnection(const std::string& host, int port) {
        // 模拟连接建立
        socket_fd = ::socket(AF_INET, SOCK_STREAM, 0);
        if (socket_fd == -1) {
            throw std::system_error(errno, std::system_category(), "socket创建失败");
        }
        connected = true;
    }
    
    ~NetworkConnection() {
        if (connected) {
            ::close(socket_fd);
        }
    }
    
    // 禁用拷贝
    NetworkConnection(const NetworkConnection&) = delete;
    NetworkConnection& operator=(const NetworkConnection&) = delete;
    
    // 支持移动
    NetworkConnection(NetworkConnection&& other) noexcept 
        : socket_fd(other.socket_fd), connected(other.connected) {
        other.connected = false;
    }
};

struct AsyncReadAwaiter {
    NetworkConnection& conn;
    std::string& buffer;
    
    bool await_ready() { return false; }
    
    void await_suspend(std::coroutine_handle<> h) {
        // 模拟异步读操作
        // 在实际项目中，这里会注册到epoll/io_uring等
        std::thread([h, this]() mutable {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            
            // 模拟读失败
            if (rand() % 10 == 0) {
                // 在恢复协程时抛出异常
                h.promise().set_exception(
                    std::make_exception_ptr(
                        std::runtime_error("网络读超时")
                    )
                );
            } else {
                buffer = "接收到的数据";
            }
            
            h.resume();
        }).detach();
    }
    
    void await_resume() {
        // 这里可以检查操作结果并抛出异常
    }
};

这个设计的关键在于使用RAII管理网络资源，确保即使在异常情况下，连接也能正确关闭。这是我通过多次线上故障总结出的经验。

实战：带异常处理的异步HTTP客户端

让我们构建一个完整的异步HTTP客户端，展示异常处理和资源管理的综合应用：


#include 
#include 
#include 

class AsyncHttpClient {
public:
    struct Response {
        int status_code;
        std::string body;
        std::string error_message;
    };
    
    struct AsyncHttpOperation {
        struct promise_type {
            Response value;
            std::exception_ptr exception;
            
            AsyncHttpOperation get_return_object() {
                return AsyncHttpOperation{
                    std::coroutine_handle::from_promise(*this)
                };
            }
            
            std::suspend_never initial_suspend() { return {}; }
            std::suspend_always final_suspend() noexcept { return {}; }
            
            void unhandled_exception() {
                exception = std::current_exception();
            }
            
            void return_value(Response resp) {
                value = std::move(resp);
            }
            
            // 资源清理保证
            ~promise_type() {
                if (exception) {
                    try {
                        std::rethrow_exception(exception);
                    } catch (const std::exception& e) {
                        std::cerr << "协程异常: " << e.what() << std::endl;
                    }
                }
            }
        };
        
        std::coroutine_handle handle;
        
        Response get() {
            if (!handle.done()) {
                handle.resume();
            }
            
            if (handle.promise().exception) {
                std::rethrow_exception(handle.promise().exception);
            }
            
            return handle.promise().value;
        }
        
        ~AsyncHttpOperation() {
            if (handle) handle.destroy();
        }
    };
    
    AsyncHttpOperation get(const std::string& url) {
        auto conn = std::make_unique("example.com", 80);
        
        try {
            // 模拟HTTP请求
            std::string request = "GET " + url + " HTTP/1.1rnrn";
            
            // 模拟网络异常
            if (url.find("timeout") != std::string::npos) {
                throw std::runtime_error("请求超时");
            }
            
            if (url.find("error") != std::string::npos) {
                throw std::runtime_error("服务器错误");
            }
            
            co_return Response{200, "响应内容", ""};
            
        } catch (...) {
            // 确保连接资源被正确释放
            conn.reset();
            throw;
        }
    }
};

异常处理的最佳实践和踩坑记录

经过多个项目的实践，我总结了以下经验：

1. 协程生命周期管理：协程句柄必须在适当的时候销毁，否则会导致内存泄漏。我建议使用RAII包装器来管理协程生命周期。

2. 异常传播边界：明确哪些异常应该在协程内部处理，哪些应该传播给调用者。网络超时可能需要在协程内部重试，而认证失败应该立即传播。

3. 资源清理顺序：确保在异常发生时，资源按照正确的顺序清理。网络连接应该在文件描述符之前关闭。


// RAII协程句柄管理
class ScopedCoroutine {
private:
    std::coroutine_handle<> handle;
    
public:
    explicit ScopedCoroutine(std::coroutine_handle<> h) : handle(h) {}
    
    ~ScopedCoroutine() {
        if (handle && !handle.done()) {
            handle.destroy();
        }
    }
    
    // 禁用拷贝
    ScopedCoroutine(const ScopedCoroutine&) = delete;
    ScopedCoroutine& operator=(const ScopedCoroutine&) = delete;
    
    // 支持移动
    ScopedCoroutine(ScopedCoroutine&& other) noexcept : handle(other.handle) {
        other.handle = nullptr;
    }
};

4. 测试策略：协程的异常路径很难测试，我建议使用依赖注入来模拟各种异常场景。特别是要测试协程在挂起状态时抛出异常的情况。