loading...

Epoll在LT和ET模式下的读写方式

发布时间:July 10, 2012 分类:Linux

VPS下CentOS装机记录

MooC的一些设计思路

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

所以,在epoll的ET模式下,正确的读写方式为:
读:只要可读,就一直读,直到返回0,或者 errno = EAGAIN
写:只要可写,就一直写,直到数据发送完,或者 errno = EAGAIN

正确的读

n = 0;
while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {
n += nread;
}
if (nread == -1 && errno != EAGAIN) {
perror("read error");
}

正确的写

int nwrite, data_size = strlen(buf);
n = data_size;
while (n > 0) {
nwrite = write(fd, buf + data_size - n, n);
if (nwrite < n) {
if (nwrite == -1 && errno != EAGAIN) {
perror("write error");
}
break;
}
n -= nwrite;
}

正确的accept,accept 要考虑 2 个问题
(1) 阻塞模式 accept 存在的问题
考虑这种情况: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模式下的正确使用方式为:

while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote, (size_t *)&addrlen)) > 0) {
handle_client(conn_sock);
}
if (conn_sock == -1) {
if (errno != EAGAIN && errno != ECONNABORTED && errno != EPROTO && errno != EINTR)
perror("accept");
}

一道腾讯后台开发的面试题
使用Linuxepoll模型,水平触发模式;当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服务器代码:

#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/epoll.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <errno.h>
#define MAX_EVENTS 10
#define PORT 8080
//设置socket连接为非阻塞模式
void setnonblocking(int sockfd) {
int opts;
opts = fcntl(sockfd, F_GETFL);
if(opts < 0) {
perror("fcntl(F_GETFL)\n");
exit(1);
}
opts = (opts | O_NONBLOCK);
if(fcntl(sockfd, F_SETFL, opts) < 0) {
perror("fcntl(F_SETFL)\n");
exit(1);
}
}
int main(){
struct epoll_event ev, events[MAX_EVENTS];
int addrlen, listenfd, conn_sock, nfds, epfd, fd, i, nread, n;
struct sockaddr_in local, remote;
char buf[BUFSIZ];
//创建listen socket
if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("sockfd\n");
exit(1);
}
setnonblocking(listenfd);
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);;
local.sin_port = htons(PORT);
if( bind(listenfd, (struct sockaddr *) &local, sizeof(local)) < 0) {
perror("bind\n");
exit(1);
}
listen(listenfd, 20);
epfd = epoll_create(MAX_EVENTS);
if (epfd == -1) {
perror("epoll_create");
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = listenfd;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {
perror("epoll_ctl: listen_sock");
exit(EXIT_FAILURE);
}
for (;;) {
nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
if (nfds == -1) {
perror("epoll_pwait");
exit(EXIT_FAILURE);
}
for (i = 0; i < nfds; ++i) {
fd = events[i].data.fd;
if (fd == listenfd) {
while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote,
(size_t *)&addrlen)) > 0) {
setnonblocking(conn_sock);
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = conn_sock;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock,
&ev) == -1) {
perror("epoll_ctl: add");
exit(EXIT_FAILURE);
}
}
if (conn_sock == -1) {
if (errno != EAGAIN && errno != ECONNABORTED
&& errno != EPROTO && errno != EINTR)
perror("accept");
}
continue;
}
if (events[i].events & EPOLLIN) {
n = 0;
while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {
n += nread;
}
if (nread == -1 && errno != EAGAIN) {
perror("read error");
}
ev.data.fd = fd;
ev.events = events[i].events | EPOLLOUT;
if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {
perror("epoll_ctl: mod");
}
}
if (events[i].events & EPOLLOUT) {
sprintf(buf, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\nHello World", 11);
int nwrite, data_size = strlen(buf);
n = data_size;
while (n > 0) {
nwrite = write(fd, buf + data_size - n, n);
if (nwrite < n) {
if (nwrite == -1 && errno != EAGAIN) {
perror("write error");
}
break;
}
n -= nwrite;
}
close(fd);
}
}
}
return 0;
}

Tags: epoll


已有 30 条评论 »

  1. 贷款 贷款

    哇塞,全是代码,看起来很高深的样子啊

  2. 贷款 贷款

    哇塞,全是代码,看起来很高深的样子啊

  3. 洁净室www.iwuchen.com 洁净室www.iwuchen.com

    二者的差异在于level-trigger模式下只要某个socket处于readable/writable状态,无论什么时候进行epoll_wait都会返回该socket;而edge-trigger模式下只有某个socket从unreadable变为readable或从unwritable变为writable时,epoll_wait才会返回该socket。

  4. 洁净棚www.qilvc.com 洁净棚www.qilvc.com

    需要向socket写数据的时候才把socket加入epoll,等待可写事件,接受到可写事件后,调用write或者send发送数据。
    当所有数据都写完后,把socket移出epoll。考虑这种情况:多个连接同时到达,服务器的TCP就绪队列瞬间积累多个就绪连接,由于是边缘触发模式,epoll只会通知一次,accept只处理一个连接,导致TCP就绪队列中剩下的连接都得不到处理。

    1. bankdev bankdev

      确实是这样的,我在做自己写的平台压力测试时候发现的,很有参考意义,谢谢

  5. 德国阳光蓄电池 德国阳光蓄电池

    支持原创

  6. 高效过滤器www.flsh.ccom 高效过滤器www.flsh.ccom

    楼主厉害啊。

  7. bp bp

    对epolll又多了一些理解,谢谢,真希望还有更全面的

  8. kevin kevin

    我碰到一种情况数据读完后,依然返回 -1 且errno == EWOULDBLOCK,然后readable就不会再触发了,导致下面的write不会执行。用的是ET模式,不知道有没有人遇到过。

    1. hayespan hayespan

      你说的这种情况行为是正确的。读端返回-1且errno==EAGAIN的意思是读缓冲区的数据已经读完了,暂时没有数据可读,如果后续写端有继续write,那么ET模式下就会通知可读。但是业务逻辑上,写端如果已经完成所有数据的写入,应该“通知”读端不用再读,例如可以关闭socket写端,这样读端read就会返回0,继续执行后续的write逻辑。

  9. lvfj lvfj

    使用Linuxepoll模型,水平触发模式;当socket可写时,会不停的触发socket可写的事件,如何处理?

    需要send的时候,epoll_ctl 加上EPOLLOUT,send完毕只要把EPOLLOUT事件移除就行了吧

  10. hexie hexie

    叔叔,你好厉害啊。

  11. buzs buzs

    int nwrite, data_size = strlen(buf);
    n = data_size;
    while (n > 0) {
    nwrite = write(fd, buf + data_size - n, n);
    if (nwrite < n) {
    if (nwrite == -1 && errno != EAGAIN) {
    perror("write error");
    }
    break;// break为什么要加在这里?如果一块数据分两次发送,是否会漏发剩下的数据包?
    }
    n -= nwrite;
    }

    1. liaohongliu liaohongliu

      我也这么认为

  12. kzangv kzangv

    epoll的两种模式LT和ET
    二者的差异在于level-trigger模式下只要某个socket处于readable/writable状态,无论什么时候进行epoll_wait 都会返回该 socket;而edge-trigger 模式下只有某个socket 从 unreadable 变为 readable 或从 unwritable 变为 writable 时,epoll_wait 才会返回该 socket。

    感觉这里对 socket EPOLLIN 的描述有点小偏差.这里不是由 unreadable 变为 readable 触发,而是由有数据到达来触发.即在 epoll_wait 部分只要有数据到达,那么就会产生 EPOLLIN 事件,而不是接收缓冲区由空变为非空来触发.

    1. 大可 大可

      回复很棒, 我开始以为是由空变为非空才触发, 原来是有数据到达便触发
      解决了误导性的问题

  13. gary gary

    提供的代码里listen的fd并没用设置edge trigger。为何还要用while处理呢?

    1. hayespan hayespan

      用while处理,如果一次有很多连接的话,效率较高。我之前写过类似server,LT模式,一次accept一个连接,相比于ET模式下while accept,性能差了很多。

  14. marco marco

    用了非阻塞,还要用while来处理读写,这跟没用非阻塞的效果是一样的,按理来说,如果此fd不可读或不可写,应该处理其他的事情,而不应该浪费cpu在while同读写这里

  15. LoveBB LoveBB

    区别在于ET不会触发epoll事件,避免while循环空转。但是这里的listenfd貌似没有设置 ET。。

  16. tianwaifeixian tianwaifeixian

    从文字上理解是这样的,et 就是假定你所有的时间都是非阻塞模式,但是不好的一点就是 如果某个文件描述长久不使用的时候,就会返回一个错误, lt 就是 把所有的事件 都处理完了之后,也是阻塞模式。

  17. 理宝 理宝

    while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {
    n += nread;
    }

    万一TCP缓存的数据比你的buf大怎么办。。。。

  18. 德州五金 德州五金

    触发epoll事件,避免while循环空转。但是这。。。

  19. 刘达 刘达

    用了epoll你还担心accept丢失,而且ET模式是只要有数据来就会触发

  20. 方晋雄 方晋雄

    Epoll ET模式下httpserver代码中没有 考虑到server端accept之后,客户端断掉或者客户端不发任何数据的情况。这种情况下应当在server端增加超时逻辑,超时后对accept到的client_fd进行释放。 需要用此段代码的朋友请注意!
    另外,MAX_EVENTS 应该如何设置呢? 跟服务器系统配置的最大句柄数相同吗?

  21. wzqt wzqt

    这么读肯定是错误的,万一数据被分片,只到了一部分数据,你要怎么办?完全没有保障机制。

  22. 邱磊 邱磊

    说的对,但是本文的重点不在这里!! 比如http头部,可以用\r\n\r\n,后接Content-Length个字节来代表结束!

  23. lxyscls lxyscls

    ET写,每次写的数量少于想写的数量,不是很正常吗?为什么要break?

  24. renwotao renwotao

    阻塞模式 accept 存在的问题这一节中,我不理解这节!!!
    ------
    考虑这种情况:TCP连接被客户端夭折,即在服务器调用accept之前,客户端主动发送RST终止连接,导致刚刚建立的连接从就绪队列中移出,如果套接口被设置成阻塞模式,服务器就会一直阻塞在accept调用上,直到其他某个客户建立一个新的连接为止。但是在此期间,服务器单纯地阻塞在accept调用上,就绪队列中的其他描述符都得不到处理。

    ---------------
    连接从就绪队列中移除,阻塞套接字阻塞在accept调用,直到某个客户建立新连接???这个怎么理解??

  25. jimmyzhuang jimmyzhuang

    使用Linuxepoll模型,水平触发模式;当socket可写时,会不停的触发socket可写的事件,如何处理?

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    一开始就把socket注册到epoll,写数据时,如果返回EAGAIN,那么epoll_ctl设置EPOLLOUT标记,下次可写后触发然后继续发送剩余数据;当数据全部发完后,可以epoll_ctl取消设置EPOLLOUT标记,这样就不会触发可写事件了。优点是:不用频繁将socket移入、移出epoll。

添加新评论 »

captcha
请输入验证码