epoll中的LT和ET读写方式

• 可读可写状态

1.下列四个条件中的任何一个知足时，一个套接口准备好读：

a.该套接口接收缓冲区中的数据字节数大等于套接口接收缓冲区的低潮标记，对于TCP和UDP而言，其缺省值为1；

b.该链接的读这一半关闭，对这样的套接口的读操做将不阻塞并返回0；

c.该套接口是一个监听套接口且已完成的链接数不为0；（就是accept成功返回)

d.其上有一个套接口错误等待处理，对这样的套接口的读操做将不阻塞并返回-1；

2.下列四个条件中的任何一个知足时，一个套接口准备好写：

a.该套接口发送缓冲区中的可用空间字节数大等于套接口发送缓冲区的低潮标记，对于TCP和UDP而言，其缺省值为2048；

b.该链接的写这一半关闭，对这样的套接口的写操做将产生SIGPIPE信号；

c.该套接口早先使用非阻塞式connect以创建链接，而且链接已经异步创建，或者connect以失败了结；

d.其上有一个套接口错误等待处理，对这样的套接口的写操做将不阻塞并返回-1；

3.select与非阻塞connect一块儿使用的时候有如下两个注意点：（1）当链接成功创建时，描述字变为可写；（2）当链接创建遇到错误时，描述字变为既可读又可写；

•  非阻塞socket读写模式

在一个非阻塞的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的错误，下次继续写

• epoll的读写模式

对于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读取数据时 LT与ET的区别

向Socket写数据时LT与ET的区别

因此，在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;

}

• epoll中的accept问题

正确的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,LT和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;// 默认 LT触发方式 用于accept
 
   
 
   
 
    
    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; //ET方式读  已链接client的读写
 
   
 
   
 
    
                    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