当前位置：首页 > news >正文

2603C++,简单实现协程

news 2026/5/12 0:36:23

如何实现简单`协程`?

什么是异步高并发,说白了,它就是个可自己控制挂起和继续的函数.
接着100多行代码,让你彻底看清楚,协程到底是怎么回事?

一,为何`协程`?

写过网络编程的,谁又没被回调地狱折磨过呢?
简单业务,用异步来写,性能是上去了,代码就变成了一坨.

voidon_request(Request req){db_query(req.id,[](DBResult res){if(res.ok){rpc_call(res.data,[](RPCResult rpc_res){if(rpc_res.ok){/*...*/}else{/*...*/}});}else{/*...*/}});}

逻辑被撕得粉碎,可读性烂到家.
想要的是既有异步的性能,又有同步代码的清爽.

协程,就是为了让你可用同步的写法,干出异步的活儿.

它允许你在耗时操作上挂起,把CPU让给别人,等完成操作了,再从挂起的地方恢复,继续往下走.

二,从玩具到工具,手撸一个分发器

要实现一个可挂起和恢复的函数,只需要三样东西:
1,保存状态,知道执行到哪了,
2,恢复入口,显式从哪继续,
3,及一个分发器,也就是谁来调用.

思路就是,用一个状态变量当PC,用switchcase当跳转表.这套组合拳就是无栈协程的精髓.

现在,直接从该思路出发,搭一个可模拟网络分发事件的架子.

需要一个Scheduler分发器,它知道哪些协程在就绪队列里,哪些在等待队列中.
协程需要IO时,就从就绪队列移动到等待队列里去,然后让出CPU.

当IO事件来了,分发器再把它挪回就绪队列.看代码:

#include<cstdio>#include<queue>#include<map>//`协程`基类和核心宏structCoroutine{intstate=0;boolfinished=false;virtual~Coroutine()=default;voidresume(){if(!finished)step();}protected:virtualvoidstep()=0;};#defineCORO_BEGIN()switch(state){case0:#defineCORO_YIELD()do{state=__LINE__;return;case__LINE__:;}while(0)#defineCORO_END()}finished=true;//分发器classScheduler{std::queue<Coroutine*>ready_queue;std::map<int,std::queue<Coroutine*>>wait_map;public:voidspawn(Coroutine*c){ready_queue.push(c);}//`协程`调用此函数以等待事件voidwait_for(Coroutine*c,intevent){wait_map[event].push(c);}//外部`事件源`调用此函数以通知事件voidnotify(intevent){if(wait_map.count(event)){auto&q=wait_map[event];while(!q.empty()){ready_queue.push(q.front());q.pop();}wait_map.erase(event);}}voidrun(){while(!ready_queue.empty()){Coroutine*c=ready_queue.front();ready_queue.pop();c->resume();if(c->finished)deletec;}}};//等待事件的宏#defineSCHED_YIELD_WAIT(sched,event)do{\(sched)->wait_for(this,event);\state=__LINE__;return;case__LINE__:;\}while(0)//模拟网络请求的`协程`structNetReader:Coroutine{Scheduler*sched;constchar*name;NetReader(Scheduler*s,constchar*n):sched(s),name(n){}protected:voidstep()override{CORO_BEGIN();printf("[%s] 开始,等待IO事件...\n",name);SCHED_YIELD_WAIT(sched,1);//等待事件1(模拟IO)printf("[%s] IO事件到达,处理完成.\n",name);CORO_END();}};intmain(){Scheduler scheduler;scheduler.spawn(newNetReader(&scheduler,"请求A"));scheduler.spawn(newNetReader(&scheduler,"请求B"));printf("分发器启动,所有`协程`将挂起等待IO...\n");scheduler.run();//`协程`执行到`SCHED_YIELD_WAIT`后挂起printf("\n--- 外部IO事件到达 ---\n");scheduler.notify(1);//唤醒所有等待事件1的`协程`printf("\n分发器再次运行,处理已就绪的`协程`...\n");scheduler.run();//执行后续逻辑return0;}

这段代码就是一套缩微的事件驱动的协程框架.主函数模拟外部世界,先运行,挂起协程;然后通知,模拟IO事件;再运行,唤醒协程继续执行.

这,就是epoll/kqueue这类IO多路复用结合协程的底层原理.

三,宏的坑与`C++20`的春天

上面的这套宏,虽然讲清了原理,但有坑.
比如不能在子函数里yield,RAII也容易失效.

幸好C++20带来了语言级的co_await.上面的NetReader,用C++20如下写出来.

#include<iostream>#include<coroutine>#include<thread>structTask{/*...样板...*/};structawaitable{/*...样板...*/};Tasknet_reader_cpp20(constchar*name){std::cout<<"["<<name<<"] Started, waiting for IO..."<<std::endl;co_awaitawaitable{};//`编译器`在此生成挂起点std::cout<<"["<<name<<"] IO received, finished."<<std::endl;}//`主`函数示意intmain(){net_reader_cpp20("Reader C++20 A");...实际需要一个分发器来驱动}

一个co_await``关键字,编译器就帮你做了之前用宏做的所有脏活累活,而且做得更好.但你只有亲手用宏撸一遍,才能真正理解co_await背后,编译器到底帮你省了多大的事.

软件干到头就是硬件,但把软件自身压榨到极限,你就是别人口中的大神.

今天从一个最简单的宏,一步步构建出一个有模有样的协程分发器,最后看到了C++20的方案.这整个过程,比你直接去背C++20``协程的八股文要有值得多.
我把协程的底裤给你扒了,但怎么穿上它,在什么场景下穿,就是你的修行了.
在你的项目里,哪个环节最适合用协程来改造?
是网络IO,还是文件读写,或是一些复杂的业务流程状态机呢?