epoll详解

在一个非阻塞的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

 

正确的读：

view sourceprint?

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 sourceprint?

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 sourceprint?

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 sourceprint?

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.}