C++20 协程(Coroutines)深度剖析：原理、实现与优化

2025/4/29 13:23:59 40 0 0 0

C++20 引入的协程（Coroutines）为异步编程带来了全新的解决方案。它不仅简化了异步代码的编写，还提供了卓越的性能。但是，要真正掌握协程的强大之处，需要深入理解其背后的原理、实现机制以及优化技巧。本文将由浅入深，抽丝剥茧，带你彻底搞懂 C++20 协程。文章面向对 C++ 并发和异步编程有一定了解，并渴望掌握协程技术的开发者。

1. 协程的本质：可恢复的函数

传统函数执行完毕后，控制权会立即返回给调用者，函数的状态也会随之销毁。而协程则不同，它可以暂停执行，将控制权交还给调度器，并在稍后恢复执行，就像从中断点继续执行一样。协程的关键特性在于其可恢复性和状态保持。

暂停与恢复：协程通过 co_await、co_yield 和 co_return 三个关键字来实现暂停和恢复。co_await 用于等待一个异步操作完成，co_yield 用于生成一个序列的值，co_return 用于返回协程的结果。
状态保持：当协程暂停时，它的局部变量、参数和执行状态都会被保存下来。当协程恢复时，它可以从之前暂停的地方继续执行，就好像什么都没发生过一样。

2. C++20 协程的骨架：Promise、Awaitable 和 Coroutine Handle

C++20 协程的实现依赖于三个核心概念：

Promise (承诺)：Promise 是协程的门面，它负责创建协程帧（Coroutine Frame），管理协程的状态，并提供与协程交互的接口。你可以把它看作是协程的“管家”，负责协程的生命周期管理。
Awaitable (可等待对象)：Awaitable 是一个可以被 co_await 的对象。它定义了协程如何暂停、恢复和处理结果。Awaitable 就像是协程的“路标”，告诉协程下一步该怎么走。
Coroutine Handle (协程句柄)：Coroutine Handle 是一个指向协程帧的指针。通过 Coroutine Handle，我们可以控制协程的执行，例如恢复协程或销毁协程。Coroutine Handle 就像是协程的“遥控器”，可以远程操控协程的运行。

三者关系如下：

当调用一个协程时，编译器会生成一个 Promise 对象。
Promise 对象负责创建协程帧，并将协程的局部变量、参数和执行状态存储在协程帧中。
当协程执行到 co_await 表达式时，会调用 Awaitable 对象的 await_ready() 方法，检查异步操作是否已经完成。
如果 await_ready() 返回 true，表示异步操作已经完成，协程会继续执行。
如果 await_ready() 返回 false，表示异步操作尚未完成，协程会调用 Awaitable 对象的 await_suspend() 方法，将协程暂停，并将 Coroutine Handle 返回给调度器。
当异步操作完成时，调度器会通过 Coroutine Handle 恢复协程的执行，调用 Awaitable 对象的 await_resume() 方法，获取异步操作的结果。
协程继续执行，直到遇到 co_return 语句，将结果存储在 Promise 对象中，并销毁协程帧。

3. 协程的运作流程：一步一步剖析

为了更清晰地理解协程的工作方式，我们来看一个简单的例子：

#include <iostream>
#include <coroutine>

struct ReturnObject {
    struct promise_type {
        ReturnObject get_return_object() { return {std::coroutine_handle<promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {}
        void return_void() {}
    };
    std::coroutine_handle<promise_type> h_;
};

ReturnObject simple_coroutine() {
    std::cout << "Coroutine started\n";
    co_await std::suspend_always{};
    std::cout << "Coroutine resumed\n";
}

int main() {
    auto coro = simple_coroutine();
    coro.h_.resume();
    coro.h_.destroy();
    return 0;
}

这个例子定义了一个简单的协程 simple_coroutine()，它首先输出 "Coroutine started"，然后暂停执行，最后恢复执行并输出 "Coroutine resumed"。

下面我们来分析一下这个协程的执行流程：

main() 函数调用 simple_coroutine()，编译器创建一个 ReturnObject::promise_type 对象，并调用其 get_return_object() 方法，返回一个 ReturnObject 对象。
ReturnObject 对象的构造函数使用 std::coroutine_handle<promise_type>::from_promise(*this) 创建一个 Coroutine Handle h_，指向协程帧。
编译器调用 promise_type::initial_suspend() 方法，决定协程是否立即暂停。在这个例子中，initial_suspend() 返回 std::suspend_never{} ，表示协程不立即暂停。
协程开始执行，输出 "Coroutine started"。
协程执行到 co_await std::suspend_always{} 表达式，std::suspend_always 是一个 Awaitable 对象，它的 await_ready() 方法返回 false，表示异步操作尚未完成。
协程调用 std::suspend_always 的 await_suspend() 方法，将协程暂停，并将 Coroutine Handle h_ 返回给 main() 函数。
main() 函数调用 coro.h_.resume() 恢复协程的执行。
协程调用 std::suspend_always 的 await_resume() 方法，这个方法什么也不做。
协程继续执行，输出 "Coroutine resumed"。
协程执行完毕，编译器调用 promise_type::final_suspend() 方法，决定协程是否在结束时暂停。在这个例子中，final_suspend() 返回 std::suspend_never{} ，表示协程不暂停。
协程销毁，编译器调用 promise_type::return_void() 方法，这个方法什么也不做。
main() 函数调用 coro.h_.destroy() 销毁协程帧。

4. 异常处理：协程中的错误捕获

在协程中处理异常与传统函数略有不同。如果协程在执行过程中抛出异常，异常会被传递到 Promise 对象的 unhandled_exception() 方法中。你可以在 unhandled_exception() 方法中处理异常，例如记录日志或终止程序。

struct ReturnObject {
    struct promise_type {
        ReturnObject get_return_object() { return {std::coroutine_handle<promise_type>::from_promise(*this)}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {
            std::cerr << "Exception caught in coroutine\n";
            std::exit(1);
        }
    };
    std::coroutine_handle<promise_type> h_;
};

ReturnObject throwing_coroutine() {
    throw std::runtime_error("Something went wrong");
    co_return;
}

int main() {
    auto coro = throwing_coroutine();
    return 0;
}

在这个例子中，throwing_coroutine() 抛出一个 std::runtime_error 异常，异常会被传递到 promise_type::unhandled_exception() 方法中，该方法输出错误信息并终止程序。

5. 性能优化：让协程飞起来

协程的性能通常优于传统的多线程方案，但如果不加以优化，也可能存在性能瓶颈。以下是一些协程性能优化的技巧：

避免不必要的内存分配：协程帧的创建和销毁会涉及内存分配，频繁的内存分配会影响性能。尽量重用协程帧，避免不必要的内存分配。
使用栈上分配：如果协程帧的大小较小，可以考虑使用栈上分配，避免堆上分配的开销。可以使用 std::experimental::coroutine_traits 来获取协程帧的大小，并使用 alloca 函数在栈上分配内存。
减少上下文切换：协程的上下文切换也需要一定的开销。尽量减少上下文切换的次数，例如将多个异步操作合并成一个协程。
使用无锁数据结构：在协程之间共享数据时，尽量使用无锁数据结构，避免锁竞争带来的性能损失。
利用编译器优化： современные компиляторы C++ (如 GCC, Clang, MSVC) 会对协程进行优化，例如内联协程、消除死代码等。开启编译器优化选项 (如 -O3) 可以提升协程的性能。

6. 实际应用：协程在异步编程中的妙用

协程非常适合用于编写异步代码，例如异步 I/O、异步网络编程等。使用协程可以避免回调地狱，使代码更加简洁易懂。

例如，我们可以使用协程来实现一个简单的异步 HTTP 客户端：

#include <iostream>
#include <asio.hpp>
#include <asio/co_spawn.hpp>
#include <asio/detached.hpp>

using asio::ip::tcp;

asio::awaitable<void> http_client(asio::io_context& io_context, const std::string& host, const std::string& path) {
    tcp::resolver resolver(io_context);
    auto endpoints = co_await resolver.async_resolve(host, "http", asio::use_awaitable);

    tcp::socket socket(io_context);
    co_await socket.async_connect(endpoints, asio::use_awaitable);

    asio::streambuf request;
    std::ostream request_stream(&request);
    request_stream << "GET " << path << " HTTP/1.0\r\n";
    request_stream << "Host: " << host << "\r\n";
    request_stream << "Accept: */*\r\n";
    request_stream << "Connection: close\r\n\r\n";
    co_await asio::async_write(socket, request, asio::use_awaitable);

    asio::streambuf response;
    co_await asio::async_read_until(socket, response, "\r\n\r\n", asio::use_awaitable);

    std::istream response_stream(&response);
    std::string header;
    while (std::getline(response_stream, header) && header != "\r") {
        std::cout << header << "\n";
    }
    std::cout << "\n";

    co_await asio::async_read(socket, response, asio::use_awaitable);

    std::cout << &response << std::endl;
}

int main() {
    asio::io_context io_context;
    asio::co_spawn(io_context, http_client(io_context, "example.com", "/"), asio::detached);
    io_context.run();
    return 0;
}

这个例子使用 asio 库和协程实现了一个简单的 HTTP 客户端。http_client() 函数使用 co_await 等待异步操作完成，例如域名解析、连接服务器、发送请求和接收响应。使用协程可以避免回调地狱，使代码更加简洁易懂。

7. 协程的局限性：需要注意的坑

虽然协程有很多优点，但也存在一些局限性：

学习曲线陡峭：协程的概念比较抽象，需要一定的学习成本才能掌握。
调试困难：协程的执行流程比较复杂，调试起来比较困难。
并非银弹：协程并非适用于所有场景。对于 CPU 密集型任务，使用协程并不能提升性能。

8. 总结：协程的未来

C++20 协程是一种强大的异步编程工具，它可以简化异步代码的编写，并提供卓越的性能。虽然协程存在一些局限性，但随着 C++ 语言的不断发展和完善，相信协程会在未来发挥更大的作用。

掌握 C++20 协程，无疑会让你在并发编程的道路上更进一步。希望本文能够帮助你深入理解协程的原理、实现和优化，并在实际项目中灵活运用协程技术。现在，就开始你的协程之旅吧！

Coroutine大师 C++20 协程异步编程