C++20 coroutines实操：用法、陷阱及最佳实践解析

# 1. C++20协程概述

## 1.1 协程简介

C++20 引入了协程，它是一种编程构造，使得函数能够挂起执行并恢复，这些函数被称为协程函数。协程允许开发者编写看起来像是同步的代码，但是执行上是非阻塞的异步代码。这极大地方便了异步编程模型，特别是在处理I/O密集型任务时，可以大幅度提高程序效率和响应性。

## 1.2 C++20协程的动机

传统线程模型在处理高并发时资源消耗大，且线程上下文切换开销高。协程作为一种轻量级的用户态线程，可以有效减少这些开销，允许更细粒度的并发控制，并在有限的资源下处理更多的并发任务。这正是C++20在设计新标准时引入协程的主要动机之一。

## 1.3 协程与C++传统编程模型的对比

在C++的传统编程模型中，开发者通常需要处理复杂的回调和状态机来实现异步操作。然而，这种模型容易导致代码难以阅读和维护。协程通过引入一些新的关键字和类型，如`co_await`, `co_yield`, `co_return`和协程句柄，允许以顺序风格编写异步代码，从而提高了代码的可读性和可维护性。

// 简单示例：协程函数使用co_await挂起和恢复
auto my_coroutine() {
    co_await some_awaitable; // 挂起，直到某个条件达成
    // 执行相关操作
    co_return; // 完成执行并返回
}

在接下来的章节中，我们将详细探讨C++20协程的基础用法，并深入理解其工作原理。

# 2. C++20协程的基础用法

## 2.1 协程的定义和组成

### 2.1.1 协程句柄和协程状态

协程在C++20中通过协程句柄（coroutine handle）和协程状态（coroutine state）进行管理。协程句柄是一种泛化的对象，用来引用协程状态，包含暂停点、恢复点以及协程完成时的清理动作。通过`std::coroutine_handle`，开发者可以操作协程的生命周期。

#include <coroutine>
#include <iostream>

struct MyCoro {
  struct promise_type {
    MyCoro get_return_object() { return MyCoro{}; }
    std::suspend_always initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void return_void() {}
    void unhandled_exception() {}
  };

  std::coroutine_handle<promise_type> h;
};

MyCoro foo() {
  co_await std::suspend_always{}; // 通过协程句柄，挂起函数foo()的执行
}

int main() {
  auto my_coro = foo();
  my_coro.h.resume(); // 恢复挂起的协程执行
  my_coro.h.destroy(); // 销毁协程状态，释放资源
}

上述代码展示了一个简单的协程定义，包括创建协程句柄，并通过其管理协程的生命周期。协程在执行`co_await`后挂起，直到被外部通过`resume()`显式恢复。最后，使用`destroy()`方法确保资源被正确释放。

### 2.1.2 操作符co_await、co_yield、co_return

这三个操作符是协程编程的核心，它们分别用于挂起当前协程（`co_await`）、产生一个中间值（`co_yield`）和结束协程并返回一个值（`co_return`）。

MyCoro producer() {
    co_yield 42; // 产生值42并挂起
    co_return; // 结束协程
}

int main() {
    auto my_coro = producer();
    my_coro.h.resume(); // 恢复协程，此时协程会返回42并挂起
    if (my_coro.h.done()) {
        std::cout << "协程已完成，返回值为: " << my_coro.h.promise().result << std::endl;
    }
}

在这个示例中，`co_yield`用于发送一个值并暂停协程，而`co_return`用于结束协程的执行。每个`co_await`、`co_yield`、`co_return`操作都将与一个`promise_type`内的方法相对应，该类型必须由程序员显式定义。

## 2.2 协程的启动和挂起

### 2.2.1 使用协程启动器和适配器

启动协程可以使用`std::coroutine_handle::from_promise()`方法，它接受一个`promise_type`对象并返回一个协程句柄，该句柄可以用来启动协程。

auto start_coroutine(MyCoro& my_coro) {
    return std::coroutine_handle<promise_type>::from_promise(my_coro.h.promise());
}

int main() {
    MyCoro my_coro;
    auto handle = start_coroutine(my_coro);
    handle.resume(); // 启动协程
    handle.destroy();
}

### 2.2.2 挂起函数和恢复点

挂起函数是协程中一个特定点，可以在该点暂停协程的执行。协程恢复后，会从挂起点继续执行。使用`co_await`操作符可以实现挂起，而`co_return`或协程函数自然结束时是恢复点。

// 示例中的producer函数就是一个挂起函数
MyCoro producer() {
    co_await std::suspend_always{}; // 挂起点
    // 协程恢复后继续执行的部分
}

## 2.3 协程的异常处理

### 2.3.1 异常传播和捕获机制

在协程中，异常的传播和捕获可以通过`try-catch`语句来实现，但需要在协程的`promise_type`中使用`unhandled_exception`来处理异常。

struct MyCoro {
    struct promise_type {
        MyCoro get_return_object() { return MyCoro{}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {
            try {
                throw; // 重新抛出异常
            } catch (...) {
                // 异常处理逻辑
            }
        }
    };

    std::coroutine_handle<promise_type> h;
};

MyCoro foo() {
    try {
        // 异常可能发生的代码区域
        throw std::exception();
    } catch (...) {
        co_await std::suspend_always{}; // 挂起异常状态下的协程
    }
    co_return;
}

int main() {
    auto my_coro = foo();
    my_coro.h.resume(); // 协程可能因为异常抛出而提前结束
    my_coro.h.destroy();
}

### 2.3.2 保证异常安全的最佳实践

为了保证异常安全，需要仔细处理协程内的资源，确保即使在异常抛出时也能正确释放。通常，这需要在`promise_type`的`final_suspend`方法中实现资源释放逻辑。

struct MyCoro {
    struct promise_type {
        MyCoro get_return_object() { return MyCoro{}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept {
            // 在协程结束前释放资源
            return {};
        }
        void return_void() {}
        void unhandled_exception() {}
    };

    std::coroutine_handle<promise_type> h;
};

int main() {
    MyCoro my_coro;
    // ... 协程的使用
    my_coro.h.destroy();
}

以上展示了异常安全处理的基本方式，通过`final_suspend`确保即使在异常情况下也能安全地清理资源。这样，无论协程是因为正常结束还是异常退出，都能保证不会发生资源泄漏。

# 3. C++20协程的高级特性

随着对C++20协程理解的深入，开发者将不可避免地接触到更高级的特性，这些特性能够使协程的使用更加灵活高效。本章节将重点介绍协程返回类型、取消与超时处理以及协程间通信等高级主题。

## 3.1 协程的返回类型

在C++20中，协程的返回类型是协程实现中的一个关键要素。它们可以被设计为返回std::future和std::promise，或者直接提供返回值。同时，需要考虑如何优化协程返回值的性能，以避免不必要的资源消耗。

### 3.1.1 std::future和std::promise

std::future和std::promise是C++标准库中提供的异步编程工具，它们可以用于在不同线程间传递信息。协程可以返回一个std::future对象，然后可以通过该对象访问异步操作的结果。std::promise则作为协程与异步操作之间的桥梁，允许协程在某个时刻传递一个值或异常给std::future。

在使用std::promise和std::future时，需要注意异常安全和资源管理。例如，当协程提前结束，需要保证std::promise能够正确处理异常，同时避免std::future对象的悬挂。

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

std::future<int> async_coroutine() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    co_await std::suspend_always{};
    prom.set_value(42);
    co_return; // 优雅地结束协程
}

int main() {
    std::future<int> result = async_coroutine();
    std::cout << "The answer is: " << result.get() << '\n';
}

### 3.1.2 协程返回值的优化策略

协程的返回值类型和传统函数不同，需要根据协程的具体行为进行设计。如果协程完成操作后返回一个值，那么直接返回该值可能是最简单有效的策略。但是，如果协程需要延迟计算值，返回一个std::future或者std::promise可能是更好的选择。

优化策略包括延迟计算（lazy evaluation）、预计算（eager evaluation）和缓存策略（caching）。开发者应根据实际应用的需求，选择最合适的策略，以减少不必要的计算和内存消耗。

## 3.2 协程的取消和超时处理

在异步编程中，取消操作和处理超时是常见需求。协程需要提供一种机制来响应取消请求，并且优雅地结束正在执行的操作。同样，超时控制对于避免程序在等待操作完成时挂起也非常重要。

### 3.2.1 取消点的设置与实现

协程的取消点可以设置在协程的挂起点，允许协程响应外部取消信号。这通常需要协程与异步操作框架紧密配合，例如使用std::stop_token来传递取消请求。

为了实现取消点，需要在协程中适当位置检查取消请求。例如，在协程的每个挂起点检查是否有取消请求，并在检测到取消时快速清理资源并退出。

#include <coroutine>
#include <iostream>
#include <stop_token>

struct MyCoro {
    struct promise_type {
        MyCoro get_return_object() { return MyCoro{this}; }
        std::suspend_always initial_suspend() { r