UNIX网络编程之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读数据:

UNIX网络编程之epoll 的accept , read, write(重要)_第1张图片
往socket写数据:

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

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

正确的读:


view source print ?
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. }


正确的写:


view source print ?
01. int nwrite, data_size = strlen(buf);
02. n = data_size;
03. while (n > 0) {
04. nwrite = write(fd, buf + data_size - n, n);
05. if (nwrite < n) {
06. if (nwrite == -1 && errno != EAGAIN) {
07. perror("write error");
08. }
09. break;
10. }
11. n -= nwrite;
12. }

正确的accept,accept 要考虑 2 个问题:参考<<UNIX网络编程——epoll的 et,lt关注点>>讲解的更加详细

(1) LT模式下或ET模式下,阻塞的监听socket, 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 模式下 的正确使用方式为:


view source print ?
01. while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote,
02. (size_t *)&addrlen)) > 0) {
03. handle_client(conn_sock);
04. }
05. if (conn_sock == -1) {
06. if (errno != EAGAIN && errno != ECONNABORTED
07. && errno != EPROTO && errno != EINTR)
08. perror("accept");
09. }

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

使用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服务器代码:


view source print ?
001. #include <sys/socket.h>
002. #include <sys/wait.h>
003. #include <netinet/in.h>
004. #include <netinet/tcp.h>
005. #include <sys/epoll.h>
006. #include <sys/sendfile.h>
007. #include <sys/stat.h>
008. #include <unistd.h>
009. #include <stdio.h>
010. #include <stdlib.h>
011. #include <string.h>
012. #include <strings.h>
013. #include <fcntl.h>
014. #include <errno.h>
015. #define MAX_EVENTS 10
016. #define PORT 8080
017. //设置socket连接为非阻塞模式
018. void setnonblocking(int sockfd) {
019. int opts;
020.
021. opts = fcntl(sockfd, F_GETFL);
022. if(opts < 0) {
023. perror("fcntl(F_GETFL)\n");
024. exit(1);
025. }
026. opts = (opts | O_NONBLOCK);
027. if(fcntl(sockfd, F_SETFL, opts) < 0) {
028. perror("fcntl(F_SETFL)\n");
029. exit(1);
030. }
031. }
032.
033. int main(){
034. struct epoll_event ev, events[MAX_EVENTS];
035. int addrlen, listenfd, conn_sock, nfds, epfd, fd, i, nread, n;
036. struct sockaddr_in local, remote;
037. char buf[BUFSIZ];
038.
039. //创建listen socket
040. if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
041. perror("sockfd\n");
042. exit(1);
043. }
044. setnonblocking(listenfd);
045. bzero(&local, sizeof(local));
046. local.sin_family = AF_INET;
047. local.sin_addr.s_addr = htonl(INADDR_ANY);;
048. local.sin_port = htons(PORT);
049. if( bind(listenfd, (struct sockaddr *) &local, sizeof(local)) < 0) {
050. perror("bind\n");
051. exit(1);
052. }
053. listen(listenfd, 20);
054.
055. epfd = epoll_create(MAX_EVENTS);
056. if (epfd == -1) {
057. perror("epoll_create");
058. exit(EXIT_FAILURE);
059. }
060. ev.events = EPOLLIN;
061. ev.data.fd = listenfd;
062. if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {
063. perror("epoll_ctl: listen_sock");
064. exit(EXIT_FAILURE);
065. }
066.
067. for (;;) {
068. nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
069. if (nfds == -1) {
070. perror("epoll_pwait");
071. exit(EXIT_FAILURE);
072. }
073.
074. for (i = 0; i < nfds; ++i) {
075. fd = events[i].data.fd;
076. if (fd == listenfd) {
077. while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote,(size_t *)&addrlen)) > 0) {
078. setnonblocking(conn_sock); //设置连接socket为非阻塞
079. ev.events = EPOLLIN | EPOLLET; //边沿触发要求套接字为非阻塞模式;水平触发可以是阻塞或非阻塞模式
080. ev.data.fd = conn_sock;
081. if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock,&ev) == -1) {
082. perror("epoll_ctl: add");
083. exit(EXIT_FAILURE);
084. }
085. }
086. if (conn_sock == -1) {
087. if (errno != EAGAIN && errno != ECONNABORTED && errno != EPROTO && errno != EINTR)
088. perror("accept");
089. }
090. continue;
091. }
092. if (events[i].events & EPOLLIN) {
093. n = 0;
094. while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {
095. n += nread;
096. }
097. if (nread == -1 && errno != EAGAIN) {
098. perror("read error");
099. }
100. ev.data.fd = fd;
101. ev.events = events[i].events | EPOLLOUT;
102. if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {
103. perror("epoll_ctl: mod");
104. }
105. }
106. if (events[i].events & EPOLLOUT) {
107. sprintf(buf, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\nHello World", 11);
108. int nwrite, data_size = strlen(buf);
109. n = data_size;
110. while (n > 0) {
111. nwrite = write(fd, buf + data_size - n, n);
112. if (nwrite < n) {
113. if (nwrite == -1 && errno != EAGAIN) {
114. perror("write error");
115. }
116. break;
117. }
118. n -= nwrite;
119. }
120. close(fd);
121. }
122. }
123. }
124. close(epfd);
125. close(listenfd);
126. return 0;
127. }

 

转自:http://www.it165.net/os/html/201308/5868.html

你可能感兴趣的:(epoll,read,write,accept,unix网络编程)