C++协程从入门到精通

文章目录

• • 一、C++协程入门知识
  • • （一）基本概念
    • （二）特点
    • （三）应用场景
    • 二、C++协程精通知识
    • • （一）高级特性
      • （二）优化技巧
      • （三）错误处理机制
      • （四）调试技巧

        一、C++协程入门知识

        （一）基本概念

        协程（coroutine）是一种特殊的函数，它可以被暂停（suspend）、恢复执行（resume），并且一个协程可以被多次调用。C++中的协程属于stackless协程，即协程被suspend时不需要堆栈。C++20开始引入协程，围绕协程实现的相应组件较多，如co_wait、co_return、co_yield，promise，handle等组件，灵活性高，组件之间的关系也略复杂，这使得C++协程学习起来有一定难度。

        协程与传统函数不同，普通函数是线程相关的，函数的状态跟线程紧密关联；而协程是线程无关的，它的状态与任何线程都没有关系。普通函数调用时，线程的栈上会记录函数的状态（参数、局部变量等），通过移动栈顶指针来完成；而协程的状态是保存在堆内存上的。当协程执行时，它跟普通函数一样依赖线程栈，但一旦暂停，其状态会独立保存在堆中，调用它的线程可以继续做其他事情，下次恢复执行时，协程可以由上次执行的线程执行，也可以由另外一个完全不同的线程执行。

        （二）特点

        1. 非阻塞：协程可以在执行过程中暂停，允许其他协程运行，从而实现非阻塞的异步编程。
        2. 轻量级：协程的创建和切换开销较小，适合高并发场景。与传统的多线程相比，协程的创建和切换不需要操作系统的调度，开销远小于线程，并且可以在单个线程中实现高并发，避免了线程上下文切换的开销。
        3. 可读性高：使用协程可以使异步代码更易于理解和维护，避免了回调地狱（callback hell）。协程允许开发者以同步的编码风格编写异步代码，提高了代码的可读性和可维护性。

        （三）应用场景

        1. 异步编程：C++20协程在异步编程中的应用非常广泛，它使得编写异步代码变得更加直观和简洁。可以使用co_await来等待异步操作的完成，而不需要使用回调函数或者Promise/Future模式。例如：

        #include 
        #include 
        struct Task {
            struct promise_type {
                Task get_return_object() { return {}; }
                std::suspend_never initial_suspend() { return {}; }
                std::suspend_never final_suspend() noexcept { return {}; }
                void return_void() {}
                void unhandled_exception() {}
            };
        };
        Task asynchronous_code() {
            // 启动一个异步操作
            // 这里简单模拟，实际中可能是一个耗时的异步函数
            co_await std::suspend_always{};
            // 在异步操作完成之后，接着运行下面的代码
            std::cout 
            auto task = asynchronous_code();
            // 这里需要手动处理协程的恢复等操作，实际中可能会有更完善的调度机制
            return 0;
        }
        
            struct promise_type {
                T current_value;
                Generator get_return_object() { return {}; }
                std::suspend_always initial_suspend() { return {}; }
                std::suspend_always final_suspend() noexcept { return {}; }
                std::suspend_always yield_value(T value) {
                    current_value = value;
                    return {}; 
                }
                void return_void() {} 
            };
            bool move_next() {
                // 恢复协程执行
                handle.resume();
                return !handle.done();
            }
            T current_value() {
                return handle.promise().current_value;
            }
            std::coroutine_handle
            int i = start;
            while (true) {
                co_yield i++;
            }
        }
        int main() {
            auto gen = integers();
            for (int i = 0; i