epoll 的accept , read, write

2024-06-22 22:48
文章标签 read epoll write accept

本文主要是介绍epoll 的accept , read, write，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

在一个非阻塞的socket上调用read/write函数, 返回EAGAIN或者EWOULDBLOCK(注: EAGAIN就是EWOULDBLOCK)

从字面上看, 意思是:

* EAGAIN: 再试一次

* EWOULDBLOCK: 如果这是一个阻塞socket, 操作将被block

* perror输出:  Resource temporarily unavailable

总结:

这个错误表示资源暂时不够, 可能read时, 读缓冲区没有数据, 或者, write时,

写缓冲区满了.  

遇到这种情况, 如果是阻塞socket, read/write就要阻塞掉.

而如果是非阻塞socket, read/write立即返回-1, 同 时errno设置为EAGAIN.

所以, 对于阻塞socket, read/write返回-1代表网络出错了.

但对于非阻塞socket, read/write返回-1不一定网络真的出错了.

可能是Resource temporarily unavailable. 这时你应该再试, 直到Resource available.

综上, 对于non-blocking的socket,  正确的读写操作为:

读: 忽略掉errno = EAGAIN的错误, 下次继续读

写: 忽略掉errno = EAGAIN的错误, 下次继续写

对于select和epoll的LT模式, 这种读写方式是没有问题的. 但对于epoll的ET模式, 这种方式还有漏洞.

epoll的两种模式 LT 和 ET

二者的差异在于 level-trigger 模式下只要某个 socket 处于 readable/writable 状态，无论什么时候

进行 epoll_wait 都会返回该 socket；而 edge-trigger 模式下只有某个 socket 从 unreadable 变为 readable 或从

unwritable 变为 writable 时，epoll_wait 才会返回该 socket。如下两个示意图:

从socket读数据:

往socket写数据

所以, 在epoll的ET模式下, 正确的读写方式为:

读: 只要可读, 就一直读, 直到返回0, 或者 errno = EAGAIN

写: 只要可写, 就一直写, 直到数据发送完, 或者 errno = EAGAIN

正确的读:

C代码   收藏代码
  1. n = 0;  
  2. while  ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {  
  3.     n += nread;  
  4. }  
  5. if  (nread == -1 && errno != EAGAIN) {  
  6.     perror( "read error" );  
  7. }  

 正确的写:

C代码   收藏代码
  1. int  nwrite, data_size = strlen(buf);  
  2. n = data_size;  
  3. while  (n > 0) {  
  4.     nwrite = write(fd, buf + data_size - n, n);  
  5.      if  (nwrite < n) {  
  6.          if  (nwrite == -1 && errno != EAGAIN) {  
  7.             perror( "write error" );  
  8.         }  
  9.          break ;  
  10.     }  
  11.     n -= nwrite;  
  12. }  

正确的accept，accept 要考虑 2 个问题

(1) 阻塞模式 accept 存在的问题

accept每次都是从已经完成三次握手的tcp队列中取出一个连接

考虑这种情况： TCP 连接被客户端夭折，即在服务器调用 accept 之前，客户端主动发送 RST 终止

连接，导致刚刚建立的连接从就绪队列中移出，如果套接口被设置成阻塞模式，服务器就会一直阻塞

在 accept 调用上，直到其他某个客户建立一个新的连接为止。但是在此期间，服务器单纯地阻塞在

accept 调用上，就绪队列中的其他描述符都得不到处理.

解决办法是把监听套接口设置为非阻塞，当客户在服务器调用 accept 之前中止某个连接时，accept 调用

可以立即返回 -1， 这时源自 Berkeley 的实现会在内核中处理该事件，并不会将该事件通知给 epool，

而其他实现把 errno 设置为 ECONNABORTED 或者 EPROTO 错误，我们应该忽略这两个错误。

(2) ET 模式下 accept 存在的问题

考虑这种情况：多个连接同时到达，服务器的 TCP 就绪队列瞬间积累多个就绪连接，由于是边缘触发模式，

 epoll 只会通知一次，accept 只处理一个连接，导致 TCP 就绪队列中剩下的连接都得不到处理。

 解决办法是用 while 循环抱住 accept 调用，处理完 TCP 就绪队列中的所有连接后再退出循环。如何知道

 是否处理完就绪队列中的所有连接呢？ accept  返回 -1 并且 errno 设置为 EAGAIN 就表示所有连接都处理完。

综合以上两种情况，服务器应该使用非阻塞地 accept， accept 在 ET 模式下 的正确使用方式为：

C代码   收藏代码
  1. while  ((conn_sock = accept(listenfd,( struct  sockaddr *) &remote,   
  2.                 ( size_t  *)&addrlen)) > 0) {  
  3.     handle_client(conn_sock);  
  4. }  
  5. if  (conn_sock == -1) {  
  6.      if  (errno != EAGAIN && errno != ECONNABORTED   
  7.             && errno != EPROTO && errno != EINTR)   
  8.         perror( "accept" );  
  9. }  

一道腾讯后台开发的面试题

使用Linux epoll模型，水平触发模式；当socket可写时，会不停的触发 socket 可写的事件，如何处理？

第一种最普遍的方式：

需要向 socket 写数据的时候才把 socket 加入 epoll ，等待可写事件。

接受到可写事件后，调用 write 或者 send 发送数据。。。

当所有数据都写完后，把 socket 移出 epoll。

这种方式的缺点是，即使发送很少的数据，也要把 socket 加入 epoll，写完后在移出 epoll，有一定操作代价。

一种改进的方式：

开始不把 socket 加入 epoll，需要向 socket 写数据的时候，直接调用 write 或者 send 发送数据。

如果返回 EAGAIN，把 socket 加入 epoll，在 epoll 的驱动下写数据，全部数据发送完毕后，再移出 epoll。

这种方式的优点是：数据不多的时候可以避免 epoll 的事件处理，提高效率。

最后贴一个使用epoll, ET模式的简单HTTP服务器代码:

[cpp]   view plain copy print ?

  1. #include <sys/socket.h>       
  2. #include <sys/wait.h>       
  3. #include <netinet/in.h>       
  4. #include <netinet/tcp.h>       
  5. #include <sys/epoll.h>       
  6. #include <sys/sendfile.h>       
  7. #include <sys/stat.h>       
  8. #include <unistd.h>       
  9. #include <stdio.h>       
  10. #include <stdlib.h>       
  11. #include <string.h>       
  12. #include <strings.h>       
  13. #include <fcntl.h>       
  14. #include <errno.h>        
  15. #define MAX_EVENTS 10       
  16. #define PORT 8080       
  17. //设置socket连接为非阻塞模式       
  18. void  setnonblocking( int  sockfd) {    
  19.      int  opts;    
  20.    
  21.    opts = fcntl(sockfd, F_GETFL);    
  22.      if (opts < 0) {    
  23.         perror( "fcntl(F_GETFL)\n" );    
  24.         exit(1);    
  25.     }    
  26.     opts = (opts | O_NONBLOCK);    
  27.      if (fcntl(sockfd, F_SETFL, opts) < 0) {    
  28.         perror( "fcntl(F_SETFL)\n" );    
  29.         exit(1);    
  30.     }    
  31. }    
  32.     
  33. int  main(){    
  34.      struct  epoll_event ev, events[MAX_EVENTS];    
  35.      int  addrlen, listenfd, conn_sock, nfds, epfd, fd, i, nread, n;    
  36.      struct  sockaddr_in local, remote;    
  37.      char  buf[BUFSIZ];    
  38.     
  39.      //创建listen socket       
  40.      if ( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {    
  41.         perror( "sockfd\n" );    
  42.         exit(1);    
  43.     }    
  44.     setnonblocking(listenfd);    
  45.     bzero(&local,  sizeof (local));    
  46.     local.sin_family = AF_INET;    
  47.     local.sin_addr.s_addr = htonl(INADDR_ANY);;    
  48.     local.sin_port = htons(PORT);    
  49.      if ( bind(listenfd, ( struct  sockaddr *) &local,  sizeof (local)) < 0) {    
  50.         perror( "bind\n" );    
  51.         exit(1);    
  52.     }    
  53.     listen(listenfd, 20);    
  54.     
  55.     epfd = epoll_create(MAX_EVENTS);    
  56.      if  (epfd == -1) {    
  57.         perror( "epoll_create" );    
  58.         exit(EXIT_FAILURE);    
  59. }      
  60.  ev.events = EPOLLIN;    
  61.     ev.data.fd = listenfd;    
  62.      if  (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {    
  63.         perror( "epoll_ctl: listen_sock" );    
  64.         exit(EXIT_FAILURE);    
  65.     }    
  66.     
  67.      for  (;;) {    
  68.         nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);    
  69.         if  (nfds == -1) {    
  70.             perror( "epoll_pwait" );    
  71.             exit(EXIT_FAILURE);    
  72.         }    
  73.     
  74.          for  (i = 0; i < nfds; ++i) {    
  75.             fd = events[i].data.fd;    
  76.              if  (fd == listenfd) {    
  77.                  while  ((conn_sock = accept(listenfd,( struct  sockaddr *) &remote,     
  78.                                 ( size_t  *)&addrlen)) > 0) {    
  79.                     setnonblocking(conn_sock);    
  80.                     ev.events = EPOLLIN | EPOLLET;    
  81.                     ev.data.fd = conn_sock;    
  82.                      if  (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock,    
  83.                                 &ev) == -1) {    
  84.                         perror( "epoll_ctl: add" );    
  85.                         exit(EXIT_FAILURE);    
  86.                     }    
  87.                 }    
  88.                  if  (conn_sock == -1) {    
  89.                      if  (errno != EAGAIN && errno != ECONNABORTED     
  90.                             && errno != EPROTO && errno != EINTR)     
  91.                         perror( "accept" );    
  92.                 }    
  93.                  continue ;    
  94.             }      
  95.              if  (events[i].events & EPOLLIN) {    
  96.                 n = 0;    
  97.                  while  ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {    
  98.                     n += nread;    
  99.                 }    
  100.                  if  (nread == -1 && errno != EAGAIN) {    
  101.                     perror( "read error" );    
  102.                 }    
  103.                 ev.data.fd = fd;    
  104.                 ev.events = events[i].events | EPOLLOUT;    
  105.                  if  (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {    
  106.                     perror( "epoll_ctl: mod" );    
  107.                 }    
  108.             }    
  109.              if  (events[i].events & EPOLLOUT) {    
  110.                 sprintf(buf,  "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\nHello World" , 11);    
  111.                  int  nwrite, data_size = strlen(buf);    
  112.                 n = data_size;    
  113.                  while  (n > 0) {    
  114.                     nwrite = write(fd, buf + data_size - n, n);    
  115.                      if  (nwrite < n) {    
  116.                          if  (nwrite == -1 && errno != EAGAIN) {    
  117.                             perror( "write error" );    
  118.                         }    
  119.                          break ;    
  120.                     }    
  121.                     n -= nwrite;    
  122.                 }    
  123.                 close(fd);    
  124.             }    
  125.         }    
  126.     }    
  127.     
  128.      return  0;    
  129. }    

这篇关于epoll 的accept , read, write的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1085633。

相关文章

github 报错 git fatal: unable to write new index file

github 报错 git fatal: unable to write new index file

错误一:git fatal: unable to write new index file主要原因就是服务器磁盘空间不够导致的，增加服务器空间就OK了在百度上面搜索没得到什么有效信息，在gooogle上搜索得到很多有效信息 Finding large directories with something like the following helped clean up some log fi
阅读更多...
linux关于epoll概述（各项组成，以及作用）

linux关于epoll概述（各项组成，以及作用）

在 Linux 中，多个进程可以各自创建自己的 epoll 对象，每个进程都有独立的 epoll 实例，即拥有独立的 eventpoll 结构体和相关的数据结构（如红黑树、就绪列表等）。 当一个进程调用 epoll_create 函数时，Linux 内核会为该进程创建一个 eventpoll 对象。这个对象用于管理该进程所关注的文件描述符及其相关事件。 每个进程通过 epoll_ctl 函数向
阅读更多...
FFplay源码分析-read_thread

FFplay源码分析-read_thread

《FFmpeg原理》的社群来了，想加入社群的朋友请购买 VIP 版，VIP 版有更高级的内容与答疑服务。 本系列 以 ffmpeg4.2 源码为准，下载地址：链接：百度网盘 提取码：g3k8 FFplay 源码分析系列以一条简单的命令开始，ffplay -i a.mp4。a.mp4下载链接：百度网盘，提取码：nl0s 。 如下图所示，本文主要讲解 read_thread() 函数的内
阅读更多...
pandas.read_csv参数

pandas.read_csv参数

官方手册 header= header=0 或None In [49]: print(data)a,b,c1,2,34,5,67,8,9In [50]: pd.read_csv(StringIO(data), names=['foo', 'bar', 'baz'], header=0)Out[50]: foo bar baz0 1 2 31 4
阅读更多...
Python的read_csv()读取大文件问题解决

Python的read_csv()读取大文件问题解决

通过普通的read_csv（）方式读取几个G的csv文件，耗时长，读不出，卡到电脑崩溃掉，结果。。。死机，强制重启 。 千万别写成： import pandas as pdmerge_dt = pd.read_csv( cwd + '\\' + SaveFile_Path + '\\' + SaveFile_Name, encoding="utf_8", engine='python' )
阅读更多...
linux下I/O模型并发的epoll多进程池协程实现

linux下I/O模型并发的epoll多进程池协程实现

方法1 主要思路： 定义了一个EventData结构体，用于存储事件相关的数据，如文件描述符、epoll 文件描述符、协程 ID 等。EchoDeal函数用于处理请求消息，并生成响应消息。handlerClient函数是协程的执行函数，用于处理客户端连接。它通过循环读取数据、解析请求、执行业务处理、发送响应等步骤，实现了对客户端请求的处理。handler函数是主函数，用于创建监听套接字、初始化
阅读更多...
调用FileOutputStream中的三种write方式

调用FileOutputStream中的三种write方式

package fileoutputstream;import java.io.FileOutputStream;import java.io.IOException;//import java.io.OutputStream;public class FileOutputStreamDemo2 {public static void main(String[] args) throws I
阅读更多...
document.write()方法总结

document.write()方法总结

document.write()方法总结 大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！document.write()方法是JavaScript中用于向HTML文档写入内容的方法之一。它允许我们在HTML文档加载过程中动态生成内容，包括文本、HTML标记和JavaScript代码等。 用法 document.write()
阅读更多...
“*** error 65: access violation at 0x40021000 : no 'read' permission”错误的解决

“*** error 65: access violation at 0x40021000 : no 'read' permission”错误的解决

错误原因： 在Keil5下面进行模拟运行的时候总是点击一下Run，程序才走一步，还从时钟配置里面出不来。 解决办法： 第一种方法 ： Option->Debug->Use_Simulator->Initialization_File，打开并新建一个.ini文件，里面写上map 0x40000000,0x400FFFFF read write保存即可（MAP不区分大小写，注意read和wri
阅读更多...
requests请求时，遇到的Accept-Encoding问题

requests请求时，遇到的Accept-Encoding问题

在使用requests请求链接的时候，发现请求得到的内容总是一堆乱码： 此时请求的headers里的Accept-Encoding是这样写的： headers = {'Accept-Encoding': 'gzip, deflate','User-Agent': str('Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:81.0) Geck
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2