C++ Coroutines (`std::coroutine_handle`)：C++20 异步编程的基石

好的，各位观众老爷们，今天咱们来聊聊C++20里那个听起来高大上，用起来有点绕的玩意儿：C++ Coroutines (协程)。别怕，咱尽量用大白话，把这玩意儿给撸清楚。

开场白：协程这货是干啥的？

想象一下，你是个厨师，要同时做红烧肉、清蒸鱼和宫保鸡丁。传统做法是，你先做完红烧肉，再做清蒸鱼，最后搞定宫保鸡丁。这叫同步，简单粗暴，但效率不高，浪费时间。

协程呢，就像你有分身术。你先开始做红烧肉，做到一半发现需要花时间炖肉，你就“暂停”一下，切换到清蒸鱼那边，开始处理鱼。等鱼处理得差不多了，又发现红烧肉炖好了，你再切回去继续搞红烧肉。这样，你就能在多个任务之间“无缝切换”，提高效率。

用程序员的语言来说，协程就是用户态的轻量级线程。它允许函数（也就是协程）在执行过程中暂停和恢复，而不需要像线程那样进行昂贵的上下文切换。

第一部分：协程的基本概念

要理解协程，得先搞清楚几个关键概念：

1. 协程函数 (Coroutine Function): 这是一个可以暂停和恢复执行的函数。它必须返回一个特殊的类型，比如 std::future, std::generator 或者你自己定义的协程类型。关键点是，协程函数里必须有 co_await, co_yield 或 co_return 中的至少一个，才能让它“暂停”下来。

2. 协程帧 (Coroutine Frame): 这是编译器自动生成的，用来存储协程的状态、局部变量、参数等信息的数据结构。每当协程暂停时，它的状态会被保存到协程帧里；恢复时，再从协程帧里读取。

3. co_await 表达式: 这是协程暂停的关键。当协程遇到 co_await 时，它会暂停执行，并将控制权返回给调用者或调度器。等到 co_await 后面跟着的 awaitable 对象“准备好”了（比如异步操作完成），协程才会恢复执行。

4. co_yield 表达式: 这是用来生成序列的。协程遇到 co_yield 时，它会暂停执行，并将 co_yield 后面的值返回给调用者。下次调用协程时，它会从上次暂停的地方继续执行。

5. co_return 语句: 这是协程结束的标志。当协程执行到 co_return 时，它会结束执行，并将 co_return 后面的值返回给调用者。

6. Awaitable 对象: co_await 表达式后面必须跟着一个 awaitable 对象。Awaitable 对象定义了协程如何暂停和恢复。 它需要实现三个方法：await_ready(), await_suspend(), 和 await_resume()。

• await_ready(): 检查 awaitable 对象是否已经准备好。如果返回 true，协程不会暂停，直接继续执行。
• await_suspend(): 负责暂停协程。它接受一个 std::coroutine_handle<> 参数，你可以用它来恢复协程。
• await_resume(): 负责恢复协程并返回结果。

7. std::coroutine_handle: 这是一个指向协程帧的指针，可以用来恢复协程的执行。

第二部分：协程的语法和用法

咱们来看几个简单的例子：

例1：最简单的协程函数

#include <iostream>
#include <coroutine>

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

ReturnObject simple_coroutine() {
  std::cout << "Coroutine startedn";
  co_return;
}

int main() {
  simple_coroutine();
  std::cout << "Main function continuedn";
  return 0;
}

这个例子啥也没干，只是打印了一些信息。ReturnObject 是协程的返回类型，它的 promise_type 定义了协程的行为。initial_suspend 和 final_suspend 都返回 std::suspend_never，表示协程不会在开始或结束时暂停。

例2：带 co_await 的协程

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

struct Task {
  struct promise_type {
    Task get_return_object() { return {}; }
    std::suspend_never initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; } //关键！
    void unhandled_exception() {}
    void return_void() {}
  };
};

struct MyAwaitable {
  bool await_ready() { return false; }
  void await_suspend(std::coroutine_handle<> h) {
    // 模拟异步操作，延迟 1 秒后恢复协程
    std::thread([h]() {
      std::this_thread::sleep_for(std::chrono::seconds(1));
      h.resume();
    }).detach();
  }
  void await_resume() {}
};

Task my_coroutine() {
  std::cout << "Coroutine startedn";
  co_await MyAwaitable{};
  std::cout << "Coroutine resumedn";
}

int main() {
  my_coroutine();
  std::cout << "Main function continuedn";
  std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待协程执行完毕
  return 0;
}

这个例子展示了 co_await 的用法。my_coroutine 函数在遇到 co_await MyAwaitable{} 时会暂停，并将控制权返回给 main 函数。MyAwaitable 的 await_suspend 方法会启动一个新线程，延迟 1 秒后恢复协程。

例3：带 co_yield 的协程 (生成器)

#include <iostream>
#include <coroutine>

template <typename T>
struct Generator {
  struct promise_type {
    T value_;
    std::exception_ptr exception_;

    Generator get_return_object() {
      return Generator(std::coroutine_handle<promise_type>::from_promise(*this));
    }
    std::suspend_always initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void unhandled_exception() { exception_ = std::current_exception(); }
    void return_void() {}
    std::suspend_always yield_value(T value) {
      value_ = value;
      return {};
    }
  };

  Generator(std::coroutine_handle<promise_type> h) : handle_(h) {}
  ~Generator() { if (handle_) handle_.destroy(); }

  Generator(const Generator&) = delete;
  Generator& operator=(const Generator&) = delete;

  bool next() {
    handle_.resume();
    return !handle_.done();
  }

  T value() {
    if (handle_.done()) {
      throw std::runtime_error("Generator exhausted");
    }
    return handle_.promise().value_;
  }

private:
  std::coroutine_handle<promise_type> handle_;
};

Generator<int> number_generator(int start, int end) {
  for (int i = start; i <= end; ++i) {
    co_yield i;
  }
}

int main() {
  auto generator = number_generator(1, 5);
  while (generator.next()) {
    std::cout << generator.value() << " ";
  }
  std::cout << std::endl;
  return 0;
}

这个例子展示了 co_yield 的用法。number_generator 函数会生成一个从 start 到 end 的整数序列。每次调用 generator.next() 时，协程会执行到 co_yield i，暂停，并将 i 的值返回给调用者。

例4：更复杂的Awaitable

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

// 模拟一个异步操作的结果
struct AsyncResult {
    int value;
    bool ready;
};

// 用于封装异步操作的 Promise
class AsyncPromise {
public:
    std::promise<AsyncResult> promise;

    // 设置异步操作的结果
    void setResult(int val) {
        promise.set_value({val, true});
    }
};

// Awaitable 对象，用于等待异步操作完成
class MyAwaitable {
public:
    MyAwaitable(AsyncPromise& p) : asyncPromise(p) {}

    bool await_ready() const {
        // 检查异步操作是否完成
        return asyncPromise.promise.get_future().wait_for(std::chrono::seconds(0)) == std::future_status::ready;
    }

    void await_suspend(std::coroutine_handle<> handle) {
        // 异步操作未完成，暂停协程，并在异步操作完成后恢复
        std::future<AsyncResult> future = asyncPromise.promise.get_future();
        std::thread([handle, future = std::move(future)]() mutable {
            AsyncResult result = future.get(); // 等待异步操作完成
            handle.resume(); // 恢复协程
        }).detach();
    }

    int await_resume() {
        // 返回异步操作的结果
        return asyncPromise.promise.get_future().get().value; // 再次get，确保await_suspend线程已经完成
    }

private:
    AsyncPromise& asyncPromise;
};

// 用于启动异步操作的函数
MyAwaitable startAsyncOperation(AsyncPromise& promise) {
    return MyAwaitable(promise);
}

// 协程函数
struct Task {
  struct promise_type {
    Task get_return_object() { return {}; }
    std::suspend_never initial_suspend() { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void unhandled_exception() {}
    void return_void() {}
  };
};

Task myCoroutine() {
    std::cout << "Coroutine started..." << std::endl;

    AsyncPromise promise;

    // 启动异步操作并等待完成
    int result = co_await startAsyncOperation(promise);

    std::cout << "Coroutine resumed with result: " << result << std::endl;

    co_return;
}

int main() {
    std::cout << "Main started..." << std::endl;

    Task task = myCoroutine();

    std::cout << "Coroutine started, doing some other work in main..." << std::endl;

    // 模拟一段时间的等待
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // 设置异步操作的结果，这会触发协程的恢复
    AsyncPromise promise;
    promise.setResult(42);

    std::cout << "Main finished..." << std::endl;

    std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待协程完成
    return 0;
}

这个例子比之前的复杂一些，它模拟了一个真实的异步操作场景。AsyncPromise 和 MyAwaitable 类一起工作，使得协程可以在等待异步操作完成时暂停，然后在操作完成后恢复。 这个例子更好的展示了Awaitable对象的完整生命周期。

第三部分：协程的 promise_type

每个协程都关联着一个 promise_type。这个类型定义了协程的行为，包括如何创建协程帧、如何处理异常、如何暂停和恢复协程，以及如何返回值。

promise_type 必须包含以下成员函数：

• get_return_object(): 返回协程的返回对象（比如 std::future, std::generator 或自定义类型）。
• initial_suspend(): 决定协程是否在开始时暂停。返回 std::suspend_always 表示暂停，返回 std::suspend_never 表示不暂停。
• final_suspend(): 决定协程是否在结束时暂停。通常返回 std::suspend_always，以防止协程帧被立即销毁。
• unhandled_exception(): 处理协程中未捕获的异常。
• return_void() 或 return_value(T value): 处理 co_return 语句。
• yield_value(T value): 处理 co_yield 语句。

第四部分：协程的优点和缺点

优点：

• 更高的效率: 协程是用户态的，上下文切换开销比线程小得多。
• 更好的可读性: 可以用同步的方式编写异步代码，避免了回调地狱。
• 更强的控制力: 可以自定义协程的调度方式。

缺点：

• 学习曲线陡峭: 协程的概念比较复杂，需要理解 promise_type, awaitable 等概念。
• 调试困难: 协程的执行流程比较复杂，调试起来比较麻烦。
• 并非万能药: 协程并不能解决所有异步编程的问题，有些场景可能更适合使用线程。

第五部分：协程的应用场景

协程在以下场景中非常有用：

• I/O 密集型应用: 比如网络服务器、数据库连接池等。
• UI 编程: 可以避免 UI 线程被阻塞。
• 游戏开发: 可以用来实现复杂的 AI 逻辑和动画效果。
• 异步算法: 比如异步排序、异步搜索等。

第六部分：与传统异步编程方式的比较

特性	线程/多进程	回调函数	Future/Promise	协程
并发模型	抢占式	非抢占式	非抢占式	非抢占式
上下文切换开销	高，涉及内核态切换	低，但需要手动管理状态	低，但需要手动管理状态	低，用户态切换
编程模型	阻塞式，代码直观	非阻塞式，容易产生回调地狱	非阻塞式，需要组合多个 Future	阻塞式外观，非阻塞式底层实现，代码更清晰
适用场景	CPU 密集型，需要并行计算	I/O 密集型，简单异步任务	I/O 密集型，复杂异步任务	I/O 密集型，需要高并发和低延迟的应用
调试难度	较高，涉及多线程同步和死锁问题	较高，回调链难以追踪	较高，需要理解 Future 的状态转换	较高，需要理解协程的暂停和恢复机制, promise_type的逻辑，但比回调好一些
资源消耗	高，每个线程需要独立的栈空间	低，但可能导致栈溢出（如果回调嵌套过深）	中等，需要额外的对象来管理异步状态	低，协程帧可以复用

第七部分：编写更好的协程代码

• 避免在协程中执行耗时操作: 尽量将耗时操作放到其他线程或进程中执行，然后在协程中 co_await 其结果。
• 小心死锁: 避免在协程中等待自身或其他协程持有的锁。
• 使用 RAII 管理资源: 确保在协程暂停时，资源能够被正确释放。
• 充分测试: 协程的执行流程比较复杂，需要进行充分的测试，以确保其正确性。
• 封装你的Awaitable: 针对你的业务逻辑，封装自定义的Awaitable对象，提高代码的可读性和可维护性。

第八部分：总结

C++ 协程是一个强大的工具，可以用来编写高效、可读性强的异步代码。但是，它也比较复杂，需要深入理解其原理和用法。希望今天的讲解能帮助大家更好地理解和使用 C++ 协程。

结束语：

协程这玩意儿，就像一把双刃剑，用好了能让你飞起来，用不好就容易把自己给砍伤。所以，大家一定要多练习，多实践，才能真正掌握它。

好了，今天的分享就到这里。谢谢大家！如果有什么问题，欢迎在评论区留言。