利用asio协程调度实现并发服务器

简介#

利用协程实现并发程序有两个好处
1 将回调函数改写为顺序调用，提高开发效率。
2 协程调度比线程调度更轻量化，因为协程是运行在用户空间的，线程切换需要在用户空间和内核空间切换。

协程案例#

asio官网提供了一个协程并发编程的案例，我们列举一下

1
#include <boost/asio/co_spawn.hpp>
2
#include <boost/asio/detached.hpp>
3
#include <boost/asio/io_context.hpp>
4
#include <boost/asio/ip/tcp.hpp>
5
#include <boost/asio/signal_set.hpp>
6
#include <boost/asio/write.hpp>
7
#include <cstdio>
8

9
using boost::asio::ip::tcp;
10
using boost::asio::awaitable;
11
using boost::asio::co_spawn;
12
using boost::asio::detached;
13
using boost::asio::use_awaitable;
14
namespace this_coro = boost::asio::this_coro;
15

16
#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
17
# define use_awaitable \
18
  boost::asio::use_awaitable_t(__FILE__, __LINE__, __PRETTY_FUNCTION__)
19
#endif
20

21
awaitable<void> echo(tcp::socket socket)
22
{
23
    try
24
    {
25
        char data[1024];
26
        for (;;)
27
        {
28
            std::size_t n = co_await socket.async_read_some(boost::asio::buffer(data), use_awaitable);
29
            co_await async_write(socket, boost::asio::buffer(data, n), use_awaitable);
30
        }
31
    }
32
    catch (std::exception& e)
33
    {
34
        std::printf("echo Exception: %s\n", e.what());
35
    }
36
}
37

38
awaitable<void> listener()
39
{
40
    auto executor = co_await this_coro::executor;
41
    tcp::acceptor acceptor(executor, { tcp::v4(), 10086 });
42
    for (;;)
43
    {
44
        tcp::socket socket = co_await acceptor.async_accept(use_awaitable);
45
        co_spawn(executor, echo(std::move(socket)), detached);
46
    }
47
}
48

49
int main()
50
{
51
    try
52
    {
53
        boost::asio::io_context io_context(1);
54

55
        boost::asio::signal_set signals(io_context, SIGINT, SIGTERM);
56
        signals.async_wait([&](auto, auto) { io_context.stop(); });
57

58
        co_spawn(io_context, listener(), detached);
59

60
        io_context.run();
61
    }
62
    catch (std::exception& e)
63
    {
64
        std::printf("Exception: %s\n", e.what());
65
    }
66
}

1 我们用awaitable声明了一个函数，那么这个函数就变为可等待的函数了，比如listener被添加awaitable<void>之后，就可以被协程调用和等待了。 2 co_spawn表示启动一个协程，参数分别为调度器，执行的函数，以及启动方式, 比如我们启动了一个协程，deatched表示将协程对象分离出来，这种启动方式可以启动多个协程，他们都是独立的，如何调度取决于调度器，在用户的感知上更像是线程调度的模式，类似于并发运行，其实底层都是串行的。

1
co_spawn(io_context, listener(), detached);

我们启动了一个协程，执行listener中的逻辑，listener内部co_await 等待 acceptor接收连接，如果没有连接到来则挂起协程。执行之后的io_context.run()逻辑。所以协程实际上是在一个线程中串行调度的，只是感知上像是并发而已。
3 当acceptor接收到连接后，继续调用co_spawn启动一个协程，用来执行echo逻辑。echo逻辑里也是通过co_wait的方式接收和发送数据的，如果对端不发数据，执行echo的协程就会挂起，另一个协程启动，继续接收新的连接。当没有连接到来，接收新连接的协程挂起，如果所有协程都挂起，则等待新的就绪事件(对端发数据，或者新连接)到来唤醒。

改进服务器#

我们可以利用协程改进服务器编码流程，用一个iocontext管理绑定acceptor用来接收新的连接，再用一个iocontext或以IOServicePool的方式管理连接的收发操作，在每个连接的接收数据时改为启动一个协程，通过顺序的方式读取收到的数据

1
void CSession::Start() {
2
    auto shared_this = shared_from_this();
3
    //开启接收协程
4
    co_spawn(_io_context, [=]()->awaitable<void> {
5
        try {
6
            for (;!_b_close;) {
7
                _recv_head_node->Clear();
8
                std::size_t n = co_await boost::asio::async_read(_socket,
9
                    boost::asio::buffer(_recv_head_node->_data, HEAD_TOTAL_LEN),
10
                    use_awaitable);
11

12
                if (n == 0) {
13
                    std::cout << "receive peer closed" << endl;
14
                    Close();
15
                    _server->ClearSession(_uuid);
16
                    co_return;
17
                }
18

19
                //获取头部MSGID数据
20
                short msg_id = 0;
21
                memcpy(&msg_id, _recv_head_node->_data, HEAD_ID_LEN);
22
                //网络字节序转化为本地字节序
23
                msg_id = boost::asio::detail::socket_ops::network_to_host_short(msg_id);
24
                std::cout << "msg_id is " << msg_id << endl;
25
                //id非法
26
                if (msg_id > MAX_LENGTH) {
27
                    std::cout << "invalid msg_id is " << msg_id << endl;
28
                    _server->ClearSession(_uuid);
29
                    co_return;
30
                }
31
                short msg_len = 0;
32
                memcpy(&msg_len, _recv_head_node->_data + HEAD_ID_LEN, HEAD_DATA_LEN);
33
                //网络字节序转化为本地字节序
34
                msg_len = boost::asio::detail::socket_ops::network_to_host_short(msg_len);
35
                std::cout << "msg_len is " << msg_len << endl;
36
                //长度非法
37
                if (msg_len > MAX_LENGTH) {
38
                    std::cout << "invalid data length is " << msg_len << endl;
39
                    _server->ClearSession(_uuid);
40
                    co_return;
41
                }
42

43
                _recv_msg_node = make_shared<RecvNode>(msg_len, msg_id);
44
                //读出包体
45
                n = co_await boost::asio::async_read(_socket,
46
                    boost::asio::buffer(_recv_msg_node->_data, _recv_msg_node->_total_len), use_awaitable);
47

48
                if (n == 0) {
49
                    std::cout << "receive peer closed" << endl;
50
                    Close();
51
                    _server->ClearSession(_uuid);
52
                    co_return;
53
                }
54

55
                _recv_msg_node->_data[_recv_msg_node->_total_len] = '\0';
56
                cout << "receive data is " << _recv_msg_node->_data << endl;
57
                //投递给逻辑线程
58
                LogicSystem::GetInstance().PostMsgToQue(make_shared<LogicNode>(shared_from_this(), _recv_msg_node));
59
            }
60

61
        }
62
        catch (std::exception& e) {
63
            std::cout << "exception is " << e.what() << endl;
64
            Close();
65
            _server->ClearSession(_uuid);
66
        }
67
        }, detached);
68

69
}

其余的逻辑和之前大体相同，测试了一下在一个iocontext负责接收新连接，一个iocontext负责接收数据和发送数据的情况下，客户端创建100个连接，收发500次，总用时为55s

简介#

协程案例#

改进服务器#

文章分享

评论区