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

相关文章

C++ I/O多路复用 select / poll / epoll

I/O多路复用:在网络I/O中,用 1个或1组线程 管理 多个连接描述符。             如果有至少一个描述符准备就绪,就处理对应的事件             如果没有,就会被阻塞,让出CPU给其他应用程序运行,直到有准备就绪的描述符 或 超时

vue 父组件调用子组件的方法报错,“TypeError: Cannot read property ‘subDialogRef‘ of undefined“

vue 父组件调用子组件的方法报错,“TypeError: Cannot read property ‘subDialogRef’ of undefined” 最近用vue做的一个界面,引入了一个子组件,在父组件中调用子组件的方法时,报错提示: [Vue warn]: Error in v-on handler: “TypeError: Cannot read property ‘methods

Unstructured cannot write mode RGBA as JPEG 错误解决

Unstructured cannot write mode RGBA as JPEG 错误解决 0. 错误详细1. 解决方法 0. 错误详细 Image Extraction Error: Skipping the failed imageTraceback (most recent call last):File "/root/miniconda3/envs/learn-y

[轻笔记] pip install : Read timed out. (closed)

添加超时参数(单位秒) pip --default-timeout=10000 install ${package_name}

Cannot read property ‘length‘ of null while opening vscode terminal

同一问题地址:Cannot read property ‘length’ of null while opening vscode terminal 问题描述 One day, 我在ubuntu 18.04下用vscode打开一个项目,并想和往常一样在vscode使用终端,发现报错Cannot read property 'length' of null。 解决 打开setting.jso

70-java write类应用场景

在Java中,我们可以使用java.io包中的FileWriter和BufferedWriter类来写入数据到文件。以下是一个简单的例子,展示了如何使用FileWriter和BufferedWriter来写入数据到文件: import java.io.BufferedWriter;import java.io.FileWriter;import java.io.IOException;pub

select、poll、epoll的区别

select、poll、epoll均为linux中的多路复用技术。3种技术出现的顺序是select、poll、epoll,3个版本反应了多路复用技术的迭代过程。我们现在开发网络应用时, 一般都会使用多路复用,很少有用一个线程来监听一个fd的,其中epoll又是最常使用的。关于epoll的实现和常见问题可以参考epoll实现原理和常见问题总结。 当我们在使用epoll的时候,会想当然的认为这种技术

SylixOS write 0 字节问题

1 问题描述 在移植中间件过程中,在SylixOS调用write函数写入0字节的数据到文件中时,会导致对应的中间件测试用例失败,失败的原因是文件系统中的write函数在Linux系统和SylixOS有区别,两种实现的差别如下。 2 write函数的实现机制 2.1 SylixOS实现机制 在SylixOS下通过write 函数写数据到普通文件中时,第一步会判断写入的数据是否为0,如果是0直

select poll epoll之间的区别比较

select,poll,epoll都是IO多路复用的机制。I/O多路复用就是通过一种机制,可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知程序进行相应的读写操作。但select,poll,epoll本质上都是同步I/O,因为他们都需要在读写事件就绪后自己负责进行读写,也就是说这个读写过程是阻塞的,而异步I/O则无需自己负责进行读写,异步I/O的实现会负责把数据从内核

王立平--Failed to push selection: Read-only file system

往android模拟器导入资源,失败。提示:只读文件、 mnt是只读文件。应点击sdcard,,在导入