恋恋风辰的官方博客

IO多路复用之epoll（二）
Posted on 2023-02-10 14:16:12 by 恋恋风辰 | In 网络编程 | 原文链接

前一篇介绍了epoll的LT模式，LT模式注意epollout事件在数据全部写成功后需要取消关注，或者更改为EPOLLIN。

而这次epoll的ET模式，要注意的是在读和写的过程中要在循环中写完或者读完所有数据，确保不要丢掉一些数据。

因为epoll ET模式只在两种边缘更改的时候触发，对于读事件只在内核缓冲区由空变为

非空通知一次用户，对于写事件，内核缓冲区只在由满变为非满的情况通知用户一次。

下面是代码

  1. int main()
  2. {
  4.     int eventsize = 20;
  5.     struct epoll_event * epoll_eventsList = (struct epoll_event *)malloc(sizeof(struct epoll_event)
  7.     *eventsize);
  9.     //打开一个空的描述符
  10.     int idlefd = open("/dev/null",O_RDONLY|O_CLOEXEC);    
  11.     cout << "idlefd" <<idlefd <<endl;    
  12.     //生成listen描述符
  14.     int listenfd = socket(PF_INET, SOCK_CLOEXEC | SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
  15.     if(listenfd < 0)
  16.     {
  17.         ERR_EXIT("socketfd");
  18.     }
  20.     //初始化地址信息
  21.     struct sockaddr_in servaddr;
  22.     memset(&servaddr,0 ,sizeof(struct sockaddr_in));
  23.     servaddr.sin_family = AF_INET;
  24.     servaddr.sin_port = htons(6667);
  25.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  28.     int on = 1;
  29.     if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
  30.     ERR_EXIT("setsockopt");
  32.     if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)))
  33.     ERR_EXIT("bindError");
  35.     if (listen(listenfd, SOMAXCONN) < 0)
  36.     ERR_EXIT("listen");
  38.     //记录客户端连接对应的socket
  39.     std::vector<int> clients;
  40.     //创建epollfd, 用于管理epoll事件表
  41.     int epollfd;
  42.     epollfd = epoll_create1(EPOLL_CLOEXEC);
  44.     struct epoll_event event;
  45.     event.data.fd = listenfd;
  46.     event.events = EPOLLIN|EPOLLET;
  47.     //将listenfd加入到epollfd管理的表里
  48.     epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event);
  50.     //用于接收新连接的客户端地址
  51.     struct sockaddr_in peeraddr;
  52.     socklen_t peerlen;
  53.     int connfd;
  54.     //为了简单起见写了个很大的数组，根据文件描述符存储内容
  55.     //其实很多项目代码采epoll.data.ptr回调具体的读写
  57.     vector<string> recievebuf;
  59.     for(int i = 0 ; i < 22222; i++)
  60.     {
  61.         recievebuf.push_back("");
  62.     }
  64.     while(1)
  65.     {
  66.         int nready = epoll_wait(epollfd, epoll_eventsList, eventsize, -1);
  67.         if (nready == -1)
  68.         {
  69.             if (errno == EINTR)
  70.             continue;
  72.             ERR_EXIT("epoll_wait");
  73.         }
  74.         if (nready == 0)
  75.         continue;
  77.         //大小不够重新开辟
  79.         if ((size_t)nready == eventsize)
  80.         {
  81.             if(eventsize * 2 >= 22222)
  82.             {
  83.                 ERR_EXIT("too many fds");
  84.             }
  86.             struct epoll_event * epoll_eventsList2 = (struct epoll_event *)malloc(sizeof(struct epoll_event) * 
  87.             eventsize *2);
  88.             if(epoll_eventsList2)
  89.             {
  90.                 memcpy(epoll_eventsList2,epoll_eventsList,sizeof(struct epoll_event) * eventsize);
  91.                 eventsize = eventsize * 2;
  92.                 free(epoll_eventsList);
  93.                 epoll_eventsList = epoll_eventsList2;
  95.             }
  98.         }
  101.         for (int i = 0; i < nready; ++i)
  102.         {
  103.             //判断wait返回的events数组状态是否正常
  104.             if ((epoll_eventsList[i].events & EPOLLERR) ||
  105.             (epoll_eventsList[i].events & EPOLLHUP))
  106.             {
  107.                 fprintf (stderr, "epoll error\n");
  108.                 close (epoll_eventsList[i].data.fd);
  109.                 continue;
  111.             }
  113.             if (epoll_eventsList[i].data.fd == listenfd)
  114.             {
  115.                 peerlen = sizeof(peeraddr);
  116.                 //ET模式accept放在while循环里
  118.                 do
  119.                 {
  120.                     connfd = ::accept4(listenfd, (struct sockaddr*)&peeraddr,
  121.                     &peerlen, SOCK_NONBLOCK | SOCK_CLOEXEC);
  123.                     if(connfd <= 0)
  124.                     break;
  126.                     std::cout<<"ip="<<inet_ntoa(peeraddr.sin_addr)<<
  127.                     " port="<<ntohs(peeraddr.sin_port)<<std::endl;
  128.                     clients.push_back(connfd);
  130.                     //将connd加入epoll表里，关注读事件
  132.                     event.data.fd = connfd;
  133.                     event.events = EPOLLIN |EPOLLET;
  134.                     epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event);
  135.                     cout << "loop" <<endl;    
  136.                     cout << "loop" << connfd << endl;
  137.                 }while(1);
  138.                 //accept失败，判断是否接收全所有的fd
  139.                 cout << connfd << endl;
  140.                 if (connfd == -1){
  141.                     if (errno != EAGAIN && errno != ECONNABORTED
  142.                         && errno != EPROTO && errno != EINTR)
  143.                         {
  144.                             cout << "error" <<endl;
  145.                             ERR_EXIT("accept");
  146.                         }    
  148.                     }
  150.                     //所有请求都处理完成
  151.                     cout << "continue"<<endl;
  152.                     continue;
  154.                 }//endif
  155.                 else if(epoll_eventsList[i].events & EPOLLIN)
  156.                 {
  157.                     connfd = epoll_eventsList[i].data.fd;    
  158.                     if(connfd > 22222)
  159.                     {
  160.                         close(connfd);
  161.                         event = epoll_eventsList[i];
  162.                         epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
  163.                         clients.erase(std::remove(clients.begin(), clients.end(), connfd), clients.end());
  164.                         continue;
  166.                     }
  168.                     char buf[1024] = {0};
  169.                     if(connfd < 0)
  170.                     continue;
  171.                     int ret = 0;
  172.                     int total = 0;
  173.                     std::string strtemp;
  174.                     while(1)
  175.                     {
  176.                         cout << "begin read" <<endl;
  177.                         ret = read(connfd, buf, 1024);
  178.                         if(ret <= 0)
  179.                         {
  180.                             break;
  181.                         }
  183.                         strtemp += string(buf);
  184.                         total += ret;
  185.                         memset(buf, 0, 1024);
  187.                         if(ret < 1024)
  188.                         {
  189.                             break;
  190.                         }
  192.                     }//endwhile(1)
  194.                     cout << "end read" <<endl;
  195.                     recievebuf[connfd] = strtemp.c_str();
  196.                     cout << "buff data :" << recievebuf[connfd]<<endl; 
  197.                     if(ret == -1)
  198.                     {
  199.                         if((errno == EAGAIN) ||
  200.                         (errno == EWOULDBLOCK))
  201.                         {
  202.                             //由于内核缓冲区空了，下次有数据到来是会触发epollin
  203.                             continue;
  204.                         }
  207.                         ERR_EXIT("read");
  209.                     }//endif ret == -1
  211.                     //连接断开
  212.                     if(ret == 0)
  213.                     {
  214.                         std::cout<<"client close"<<std::endl;
  215.                         close(connfd);
  216.                         event = epoll_eventsList[i];
  217.                         epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
  218.                         clients.erase(std::remove(clients.begin(), clients.end(), connfd), clients.end());
  219.                         continue;
  221.                     }
  223.                     cout << "turn to write" << endl;
  224.                     //更改为写模式
  226.                     event.data.fd = connfd;
  227.                     event.events = EPOLLOUT | EPOLLET;
  229.                     epoll_ctl(epollfd, EPOLL_CTL_MOD, connfd, &event);
  230.                     cout << "epoll mod change success" << endl;
  232.                 }//end elif
  234.                 else //写事件
  235.                 {
  237.                     if(epoll_eventsList[i].events & EPOLLOUT)
  238.                     {
  239.                         cout << "begin write" <<endl;
  240.                         connfd = epoll_eventsList[i].data.fd;
  241.                         int count = 0;
  242.                         int totalsend = 0;
  243.                         char buf[1024];
  244.                         strcpy(buf, recievebuf[connfd].c_str());
  246.                         cout << "write buff" <<buf<<endl;
  247.                         while(1)
  248.                         {
  249.                             int totalcount = strlen(buf);
  250.                             int pos = 0;
  251.                             count = write(epoll_eventsList[i].data.fd, buf + pos, totalcount);
  252.                             cout << "write count:" << count;
  253.                             if(count < 0)
  254.                             {
  255.                                 break;
  256.                             }
  258.                             if(count < totalcount)
  259.                             {
  260.                                 totalcount = totalcount - count;
  261.                                 pos += count;
  263.                             }
  264.                             else
  265.                             {
  266.                                 break;
  268.                             }
  270.                         }//end while
  273.                         if(count == -1)
  274.                         {
  275.                             if((errno == EAGAIN) ||
  276.                             (errno == EWOULDBLOCK))
  277.                             {
  278.                                 //由于内核缓冲区满了
  279.                                 //于内核缓冲区满了
  280.                                 continue;
  281.                             }
  283.                             ERR_EXIT("write");
  284.                         }
  286.                         if(count == 0)
  287.                         {
  288.                             std::cout<<"client close"<<std::endl;
  289.                             close(connfd);
  290.                             event = epoll_eventsList[i];
  291.                             epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
  292.                             clients.erase(std::remove(clients.begin(), clients.end(), connfd), 
  293.                             clients.end());
  294.                             continue;
  296.                         }
  298.                         event.data.fd = connfd;
  299.                         event.events = EPOLLIN|EPOLLET;
  300.                         epoll_ctl(epollfd, EPOLL_CTL_MOD, connfd, &event);
  302.                     }
  304.                 }//end eles 写事件
  307.             }
  309.         }
  310.     }

源代码下载地址：http://download.csdn.net/detail/secondtonone1/9486222
我的微信公众号：
https://cdn.llfc.club/gzh.jpg

热门评论
点击查看更多评论 没有更多评论了,点击收起 展开评论

热门文章

  1. vscode搭建windows C++开发环境
    喜欢(596) 浏览(83130)

  2. 聊天项目(28) 分布式服务通知好友申请
    喜欢(507) 浏览(6091)

  3. 使用hexo搭建个人博客
    喜欢(533) 浏览(11859)

  4. Linux环境搭建和编码
    喜欢(594) 浏览(13513)

  5. Qt环境搭建
    喜欢(517) 浏览(24625)

最新评论

  1. 堆排序 secondtonone1:堆排序非常实用，定时器就是这个原理制作的。
  2. 创建项目和编译 secondtonone1:谢谢支持
  3. 类和对象 陈宇航:支持！！！！
  4. boost::asio之socket的创建和连接 项空月:发现一些错别字 :每隔vector存储  是不是是每个. asio::mutable_buffers_1 o或者    是不是多打了个o
  5. 聊天项目(9) redis服务搭建 pro_lin:redis线程池的析构函数，除了pop出队列，还要free掉redis连接把
  6. 利用栅栏实现同步 Dzher:作者你好！我觉得 std::thread a(write_x); std::thread b(write_y); std::thread c(read_x_then_y); std::thread d(read_y_then_x); 这个例子中的assert fail并不会发生，原子变量设定了非relaxed内存序后一个线程的原子变量被写入，那么之后的读取一定会被同步的，c和d线程中只可能同时发生一个z++未执行的情况，最终z不是1就是2了，我测试了很多次都没有assert，请问我这个观点有什么错误，谢谢！
  7. 可变参数模板+异步队列实现异步打印功能 熊二:学到了%%%
  8. C++ 并发三剑客future, promise和async Yunfei:大佬您好，如果这个线程池中加入的异步任务的形参如果有右值引用，这个commit中的返回类型推导和bind绑定就会出现问题，请问实际工程中，是不是不会用到这种任务，如果用到了，应该怎么解决？
  9. string类 WangQi888888:确实错了，应该是！isspace(sind[index]). 否则不进入循环，还是原来的字符串“some string”
  10. 答疑汇总(thread,async源码分析) Yagus:如果引用计数为0，则会执行 future 的析构进而等待任务执行完成，那么看到的输出将是 这边应该不对吧，std::future析构只在这三种情况都满足的时候才回block: 1.共享状态是std::async 创造的(类型是_Task_async_state) 2.共享状态没有ready 3.这个future是共享状态的最后一个引用 这边共享状态类型是“_Package_state”，引用计数即使为0也不应该block啊
  11. Qt 对话框 Spade2077:QDialog w(); //这里是不是不需要带括号
  12. visual studio配置boost库 一giao里我离giaogiao:请问是修改成这样吗：.\b2.exe toolset=MinGW
  13. 面试题汇总(一) secondtonone1:看到网络上经常提问的go的问题，做了一下汇总，结合自己的经验给出的答案，如有纰漏，望指正批评。
  14. 聊天项目(15) 客户端实现TCP管理者 lkx:已经在&QTcpSocket::readyRead 回调函数中做了处理了的。
  15. interface应用 secondtonone1:interface是万能类型，但是使用时要转换为实际类型来使用。interface丰富了go的多态特性，也降低了传统面向对象语言的耦合性。
  16. 处理网络粘包问题 zyouth: //消息的长度小于头部规定的长度，说明数据未收全，则先将部分消息放到接收节点里 if (bytes_transferred < data_len) { memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred); _recv_msg_node->_cur_len += bytes_transferred; ::memset(_data, 0, MAX_LENGTH); _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self)); //头部处理完成 _b_head_parse = true; return; } 把_b_head_parse = true;放在_socket.async_read_some前面是不是更好
  17. 构造函数 secondtonone1:构造函数是类的基础知识，要着重掌握
  18. Qt MVC结构之QItemDelegate介绍 胡歌-此生不换:gpt, google
  19. 聊天项目(7) visualstudio配置grpc diablorrr:cmake文件得改一下 find_package(Boost REQUIRED COMPONENTS system filesystem)，要加上filesystem。在target_link_libraries中也同样加上
  20. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理，无论工作也好生活也罢，最重要的是开心，即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃，所以我还是想去做喜欢的方向。
  21. 无锁并发队列 TenThousandOne:_head  和 _tail  替换为原子变量。那里pop的逻辑，val = _data[h] 可以移到循环外面吗
  22. 网络编程学习方法和图书推荐 Corleone:啥程度可以找工作
  23. 再谈单例模式 secondtonone1:是的，C++11以后返回局部static变量对象能保证线程安全了。
  24. protobuf配置和使用 熊二:你可以把dll放到系统目录，也可以配置环境变量，还能把dll丢到lib里

其他链接

  1. GitHub
  2. 个人博客
  3. 博客园
  4. CSDN

个人公众号

个人微信