c++怎么使用C++ Coroutines和Boost.Asio_C++协程结合Asio实现异步编程示例_技术教程

C++协程结合Boost.Asio实现异步编程，通过co_await和awaitable以同步风格编写异步代码，避免回调地狱，需使用C++20兼容编译器并启用use_awaitable，示例包括TCP回显服务器和HTTP客户端，关键点为返回awaitable类型、用co_spawn启动协程、正确处理异常与资源生命周期。

使用C++ Coroutines（协程）结合Boost.Asio可以实现现代、简洁的异步编程模型。C++20引入了原生协程支持，配合Boost.Asio的awaitable特性，能以同步风格编写异步代码，避免回调地狱。

启用协程支持

确保编译器支持C++20协程，并链接Boost.Asio中对协程的支持模块。需要：

使用支持C++20的编译器（如GCC 11+、Clang 14+）
包含
使用 co_await 和返回类型 boost::asio::awaitable

基本示例：TCP回显服务器

以下是一个简单的TCP回显服务，使用协程处理客户端连接：

#include 
#include 

using boost::asio::ip::tcp;
using namespace std::literals;

boost::asio::awaitable echo_session(tcp::socket socket) {
    try {
        char data[1024];
        for (;;) {
            auto n = co_await socket.async_read_some(
                boost::asio::buffer(data), 
                boost::asio::use_awaitable
            );
            co_await boost::asio::async_write(
                socket, 
                boost::asio::buffer(data, n),
                boost::asio::use_awaitable
            );
        }
    } catch (const std::exception& e) {
        std::cerr << "Session error: " << e.what() << "\n";
    }
}

boost::asio::awaitable listener() {
    auto executor = co_await boost::asio::this_coro::executor;
    tcp::acceptor acceptor(executor, {tcp::v4(), 8080});

    for (;;) {
        tcp::socket socket = co_await acceptor.async_accept(boost::asio::use_awaitable);
        boost::asio::co_spawn(
            executor,
            echo_session(std::move(socket)),
            boost::asio::detached
        );
    }
}

int main() {
    try {
        boost::asio::io_context ctx;
        boost::asio::co_spawn(ctx, listener(), boost::asio::detached);
        ctx.run();
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << "\n";
    }
    return 0;
}

关键点说明

返回类型为 awaitable：每个协程函数返回 boost::asio::awaitable 或带值的模板类型。

使用 use_awaitable：代替传统的回调，传入 boost::asio::use_awaitable 让异步操作可被 co_await。

协程调度：boost::asio::co_spawn 启动协程并将其交给执行上下文管理。

异常处理：协程内部的异常需用 try/catch 捕获，否则会终止程序。

HTTP客户端示例（DNS + TCP）

演示更复杂的链式异步操作：

boost::asio::awaitable fetch_http() {
    tcp::resolver resolver = co_await boost::asio::this_coro::make_resolver();
    auto endpoints = co_await resolver.async_resolve("httpbin.org", "80", boost::asio::use_awaitable);

    tcp::socket socket = co_await boost::asio::this_coro::make_socket();
    co_await boost::asio::async_connect(socket, endpoints, boost::asio::use_awaitable);

    std::string request = "GET /get HTTP/1.1\r\nHost: httpbin.org\r\nConnection: close\r\n\r\n";
    co_await boost::asio::async_write(socket, boost::asio::buffer(request), boost::asio::use_awaitable);

    std::string response;
    char buf[1024];
    for (;;) {
        auto n = co_await socket.async_read_some(boost::asio::buffer(buf), boost::asio::use_awaitable);
        response.append(buf, n);
        if (n < sizeof(buf)) break;
    }

    co_return response;
}

在主线程中调用：

boost::asio::co_spawn(ctx, []() -> boost::asio::awaitable {
    try {
        std::string result = co_await fetch_http();
        std::cout << result << std::endl;
    } catch (...) {
        std::cerr << "Request failed\n";
    }
}, boost::asio::detached);

基本上就这些。协程让异步逻辑变得清晰，不再依赖嵌套回调。只要注意资源生命周期（如socket移动）、异常安全和正确使用awaitable上下文，就能写出高效且易维护的网络服务。