c++怎么实现一个简单的协程库_c++手写协程实现原理与示例

#include <iostream>
#include <ucontext.h>
#include <map>
#include <functional>
#include <cstdlib>

class SimpleCoroutine {
private:
    static std::map<int, ucontext_t> coroutines;
    static int current_id;
    static ucontext_t main_context;

    ucontext_t ctx;
    char* stack;
    int id;
    bool is_done;

public:
    SimpleCoroutine(std::function<void()> func) {
        id = ++current_id;
        stack = new char[8192]; // 8KB 栈空间
        is_done = false;

        getcontext(&ctx);
        ctx.uc_stack.ss_sp = stack;
        ctx.uc_stack.ss_size = 8192;
        ctx.uc_link = &main_context; // 协程结束回到主上下文
        makecontext(&ctx, (void(*)())lambda_wrapper, 1, this);

        coroutines[id] = ctx;
    }

    ~SimpleCoroutine() {
        delete[] stack;
    }

    static void lambda_wrapper(SimpleCoroutine* self) {
        self->is_done = false;
        self->run();
        self->is_done = true;
    }

    void run() {
        // 模拟协程体
        std::cout << "协程 " << id << " 开始执行\n";
        yield(); // 第一次让出
        std::cout << "协程 " << id << " 继续执行\n";
        yield();
        std::cout << "协程 " << id << " 执行结束\n";
    }

    void resume() {
        if (is_done) return;
        swapcontext(&main_context, &coroutines[id]);
    }

    static void yield() {
        swapcontext(&coroutines[current_id], &main_context);
    }

    static void yield(int cid) {
        swapcontext(&coroutines[current_id], &main_context);
    }
};

// 静态成员定义
std::map<int, ucontext_t> SimpleCoroutine::coroutines;
int SimpleCoroutine::current_id = 0;
ucontext_t SimpleCoroutine::main_context;

int main() {
    getcontext(&SimpleCoroutine::main_context);

    SimpleCoroutine co1([]{}); // lambda 只是为了占位，实际逻辑在 run 中
    SimpleCoroutine co2([]{});

    std::cout << "主函数启动协程1\n";
    co1.resume();

    std::cout << "主函数启动协程2\n";
    co2.resume();

    std::cout << "主函数再次恢复协程1\n";
    co1.resume();

    std::cout << "主函数再次恢复协程2\n";
    co2.resume();

    return 0;
}

主函数启动协程1
协程 1 开始执行
主函数启动协程2
协程 2 开始执行
主函数再次恢复协程1
协程 1 继续执行
主函数再次恢复协程2
协程 2 继续执行