boost 对称协程symmetric_coroutine

boost 提供了两种协程类型：对称协程（symmetric_coroutine）和非对称协程（asymmetric_coroutine）。

以下示例演示 symmetric_coroutine 的基本用法，分别创建一个收协程和一个发协程，两者交替切换执行：

#include "boost_1_60_0/boost/coroutine/coroutine.hpp"
                
                int main()
                {
                	using   Coroutine_t = boost::coroutines::symmetric_coroutine<int>;
                
                	Coroutine_t::call_type coro_recv(
                		[&](Coroutine_t::yield_type& yield) {
                		//loop for recv
                		for (;;)
                		{
                			std::cout << yield.get() << " recv" << endl;
                			yield(); //give up time  slice and jump back to starting context
                		}
                	});
                
                	Coroutine_t::call_type coro_send(
                		[&](Coroutine_t::yield_type& yield) {
                		//loop for send
                		for (;;)
                		{
                			yield.get();
                			std::cout << yield.get() << " send" << endl;
                			yield();
                		}
                	});
                
                
                	while (true)
                	{
                		coro_recv(1); //recv
                
                		coro_send(1); // send
                
                	}
                
                	system("pause");
                
                	return 0;
                }
                

此外，可以结合 ASIO 的定时器与协程来完成定时任务。以下示例创建两个协程，分别以 1 秒和 500 毫秒为间隔轮询执行：

#include "boost_1_60_0/boost/asio/steady_timer.hpp"
                #include "boost_1_60_0/boost/asio/spawn.hpp"
                int main()
                {
                	boost::asio::io_service io;
                
                	boost::asio::steady_timer timer(io);
                	using namespace boost::asio;
                
                
                	//协程1
                	spawn(io, [&](yield_context yield) {
                		while (true)
                		{
                			boost::asio::steady_timer timer(io);
                			timer.expires_from_now(std::chrono::seconds(1));
                			timer.async_wait(yield);
                
                			cout << "1111111111" << endl;;
                		}
                	});
                
                	//协程2
                	spawn(io, [&](yield_context yield) {
                		while (true)
                		{
                			boost::asio::steady_timer timer(io);
                			timer.expires_from_now(std::chrono::milliseconds(500));
                			timer.async_wait(yield);
                
                			cout << "22222222222"<<endl;
                		}
                	});
                
                
                	io.run();//
                
                
                
                	while (true)
                	{
                		Sleep(100);
                	}
                
                
                	system("pause");
                
                	return 0;
                }