asio官方案例存在的隐患

简介

前文已经介绍了异步操作的api,今天写一个简单的异步echo服务器,以应答为主

Session类

Session类主要是处理客户端消息收发的会话类,为了简单起见,我们不考虑粘包问题,也不考虑支持手动调用发送的接口,只以应答的方式发送和接收固定长度(1024字节长度)的数据。
<!--more-->

  1. class Session
  2. {
  3. public:
  4. Session(boost::asio::io_context& ioc):_socket(ioc){
  5. }
  6. tcp::socket& Socket() {
  7. return _socket;
  8. }
  9. void Start();
  10. private:
  11. void handle_read(const boost::system::error_code & error, size_t bytes_transfered);
  12. void handle_write(const boost::system::error_code& error);
  13. tcp::socket _socket;
  14. enum {max_length = 1024};
  15. char _data[max_length];
  16. };

1   _data用来接收客户端传递的数据
2   _socket为单独处理客户端读写的socket。
3   handle_read和handle_write分别为读回调函数和写回调函数。
接下来我们实现Session类

  1. void Session::Start(){
  2. memset(_data, 0, max_length);
  3. _socket.async_read_some(boost::asio::buffer(_data, max_length),
  4. std::bind(&Session::handle_read, this, placeholders::_1,
  5. placeholders::_2)
  6. );
  7. }

在Start方法中我们调用异步读操作,监听对端发送的消息。当对端发送数据后,触发handle_read函数

  1. void Session::handle_read(const boost::system::error_code& error, size_t bytes_transfered) {
  2. if (!error) {
  3. cout << "server receive data is " << _data << endl;
  4. boost::asio::async_write(_socket, boost::asio::buffer(_data, bytes_transfered),
  5. std::bind(&Session::handle_write, this, placeholders::_1));
  6. }
  7. else {
  8. delete this;
  9. }
  10. }

handle_read函数内将收到的数据发送给对端,当发送完成后触发handle_write回调函数。

  1. void Session::handle_write(const boost::system::error_code& error) {
  2. if (!error) {
  3. memset(_data, 0, max_length);
  4. _socket.async_read_some(boost::asio::buffer(_data, max_length), std::bind(&Session::handle_read,
  5. this, placeholders::_1, placeholders::_2));
  6. }
  7. else {
  8. delete this;
  9. }
  10. }

handle_write函数内又一次监听了读事件,如果对端有数据发送过来则触发handle_read,我们再将收到的数据发回去。从而达到应答式服务的效果。

Server类

Server类为服务器接收连接的管理类

  1. class Server {
  2. public:
  3. Server(boost::asio::io_context& ioc, short port);
  4. private:
  5. void start_accept();
  6. void handle_accept(Session* new_session, const boost::system::error_code& error);
  7. boost::asio::io_context& _ioc;
  8. tcp::acceptor _acceptor;
  9. };

start_accept将要接收连接的acceptor绑定到服务上,其内部就是将accpeptor对应的socket描述符绑定到epoll或iocp模型上,实现事件驱动。
handle_accept为新连接到来后触发的回调函数。
下面是具体实现

  1. Server::Server(boost::asio::io_context& ioc, short port) :_ioc(ioc),
  2. _acceptor(ioc, tcp::endpoint(tcp::v4(), port)) {
  3. start_accept();
  4. }
  5. void Server::start_accept() {
  6. Session* new_session = new Session(_ioc);
  7. _acceptor.async_accept(new_session->Socket(),
  8. std::bind(&Server::handle_accept, this, new_session, placeholders::_1));
  9. }
  10. void Server::handle_accept(Session* new_session, const boost::system::error_code& error) {
  11. if (!error) {
  12. new_session->Start();
  13. }
  14. else {
  15. delete new_session;
  16. }
  17. start_accept();
  18. }

客户端

客户端的设计用之前的同步模式即可,客户端不需要异步的方式,因为客户端并不是以并发为主,当然写成异步收发更好一些。

  1. #include <iostream>
  2. #include <boost/asio.hpp>
  3. using namespace std;
  4. using namespace boost::asio::ip;
  5. const int MAX_LENGTH = 1024;
  6. int main()
  7. {
  8. try {
  9. //创建上下文服务
  10. boost::asio::io_context ioc;
  11. //构造endpoint
  12. tcp::endpoint remote_ep(address::from_string("127.0.0.1"), 10086);
  13. tcp::socket sock(ioc);
  14. boost::system::error_code error = boost::asio::error::host_not_found; ;
  15. sock.connect(remote_ep, error);
  16. if (error) {
  17. cout << "connect failed, code is " << error.value() << " error msg is " << error.message();
  18. return 0;
  19. }
  20. std::cout << "Enter message: ";
  21. char request[MAX_LENGTH];
  22. std::cin.getline(request, MAX_LENGTH);
  23. size_t request_length = strlen(request);
  24. boost::asio::write(sock, boost::asio::buffer(request, request_length));
  25. char reply[MAX_LENGTH];
  26. size_t reply_length = boost::asio::read(sock,
  27. boost::asio::buffer(reply, request_length));
  28. std::cout << "Reply is: ";
  29. std::cout.write(reply, reply_length);
  30. std::cout << "\n";
  31. }
  32. catch (std::exception& e) {
  33. std::cerr << "Exception: " << e.what() << endl;
  34. }
  35. return 0;
  36. }

运行服务器之后再运行客户端,输入字符串后,就可以收到服务器应答的字符串了。

隐患

该demo示例为仿照asio官网编写的,其中存在隐患,就是当服务器即将发送数据前(调用async_write前),此刻客户端中断,服务器此时调用async_write会触发发送回调函数,判断ec为非0进而执行delete this逻辑回收session。但要注意的是客户端关闭后,在tcp层面会触发读就绪事件,服务器会触发读事件回调函数。在读事件回调函数中判断错误码ec为非0,进而再次执行delete操作,从而造成二次析构,这是极度危险的。

总结

本文介绍了异步的应答服务器设计,但是这种服务器并不会在实际生产中使用,主要有两个原因:
1   因为该服务器的发送和接收以应答的方式交互,而并不能做到应用层想随意发送的目的,也就是未做到完全的收发分离(全双工逻辑)。
2   该服务器未处理粘包,序列化,以及逻辑和收发线程解耦等问题。
3   该服务器存在二次析构的风险。
这些问题我们会在接下来的文章中不断完善
源码链接
https://gitee.com/secondtonone1/boostasio-learn

热门评论

热门文章

  1. Linux环境搭建和编码

    喜欢(594) 浏览(6419)
  2. C++ 类的继承封装和多态

    喜欢(588) 浏览(2960)
  3. 解密定时器的实现细节

    喜欢(566) 浏览(2125)
  4. windows环境搭建和vscode配置

    喜欢(587) 浏览(1801)
  5. slice介绍和使用

    喜欢(521) 浏览(1880)

最新评论

  1. C++ 虚函数表原理和类成员内存分布 WangQi888888:class Test{ int m; int b; }中b成员是int,为什么在内存中只占了1个字节。不应该是4个字节吗?是不是int应该改为char。这样的话就会符合图上说明的情况
  2. 类和对象 陈宇航:支持!!!!
  3. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理,无论工作也好生活也罢,最重要的是开心,即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃,所以我还是想去做喜欢的方向。
  4. slice介绍和使用 恋恋风辰:切片作为引用类型极大的提高了数据传递的效率和性能,但也要注意切片的浅拷贝隐患,算是一把双刃剑,这世间的常态就是在两极之间寻求一种稳定。
  5. 泛型算法的定制操作 secondtonone1:lambda和bind是C11新增的利器,善于利用这两个机制可以极大地提升编程安全性和效率。

个人公众号

个人微信