实现一个简单的协程调度器需要理解 C++20 协程的核心机制：可等待对象（awaiter）、协程句柄（coroutine_handle）和协程帧的生命周期管理。C++20 的协程是无栈协程，依赖编译器生成状态机，我们通过自定义返回类型控制其行为。

协程基础组件

要让函数成为协程，必须使用 co_await、co_yield 或 co_return。协程的返回类型需满足特定要求，包含 promise_type。

定义一个简单的协程返回类型：

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

其中：

• initial_suspend 返回 suspend_always 表示协程创建后暂停，不立即执行
• final_suspend 控制协程结束后是否挂起，用于防止资源提前释放

实现调度器核心

调度器负责管理多个协程的挂起与恢复。基本思路是将挂起的协程句柄存入队列，之后主动唤醒。

扩展 Task 支持获取协程句柄：

struct Task {
    struct promise_type;
    std::coroutine_handle handle;

    explicit Task(std::coroutine_handle h) : handle(h) {}

    ~Task() {
        if (handle) handle.destroy();
    }

    bool await_ready() { return false; }
    void await_suspend(std::coroutine_handle<>) {}
    void await_resume() {}

    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle::from_promise(*this)};
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

任务队列与运行

调度器维护一个待执行的协程队列：

class Scheduler {
public:
    void enqueue(Task task) {
        if (task.handle) {
            tasks.push(std::move(task.handle));
        }
    }

    void run() {
        while (!tasks.empty()) {
            auto handle = std::move(tasks.front());
            tasks.pop();
            if (handle.done()) continue;
            handle.resume();
        }
    }

private:
    std::queue> tasks;
};

使用示例：

Task myCoroutine(Scheduler& sched) {
    std::cout << "协程开始\n";
    co_await std::suspend_always{};
    std::cout << "协程恢复\n";
}

// 调用
Scheduler sched;
sched.enqueue(myCoroutine(sched));
sched.run(); // 输出两次

关键注意事项

• 协程句柄必须妥善管理生命周期，避免悬空调用
• 挂起点的选择影响并发模型，suspend_always 适合手动调度
• 实际项目中可结合 future/promise 模式传递结果
• 错误处理应在 unhandled_exception 中捕获并重新抛出

基本上就这些。C++20 协程灵活但细节多，重点掌握 promise 和 awaiter 的交互逻辑。