恋恋风辰的官方博客

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. 解密定时器的实现细节
    喜欢(566) 浏览(1829)

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

  3. slice介绍和使用
    喜欢(521) 浏览(1703)

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

  5. windows环境搭建和vscode配置
    喜欢(587) 浏览(1708)

最新评论

  1. 利用内存模型优化无锁栈 卡西莫多的礼物:感谢博主指点，好人一生平安o(*￣▽￣*)ブ
  2. 类和对象 陈宇航:支持！！！！
  3. 泛型算法的定制操作 secondtonone1:lambda和bind是C11新增的利器，善于利用这两个机制可以极大地提升编程安全性和效率。
  4. 基于锁实现线程安全队列和栈容器 secondtonone1:我是博主，你认真学习的样子的很可爱，哈哈，我画的是链表由空变成1个的情况。其余情况和你思考的类似，只不过我用了一个无效节点表示tail的指向，最初head和tail指向的都是这个节点。
  5. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理，无论工作也好生活也罢，最重要的是开心，即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃，所以我还是想去做喜欢的方向。

其他链接

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

个人公众号

个人微信