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