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

正確的讀:

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

 正確的寫:

1. int nwrite, data_size = strlen(buf);  
2. n = data_size;  
3. while (n > 0) {  
4.     nwrite = write(fd, buf + data_size - n, n);  
5.     if (nwrite < n) {  
6.         if (nwrite == -1 && errno != EAGAIN) {  
7.             perror("write error");  
8.         }  
9.         break;  
10.     }  
11.     n -= nwrite;  
12. }  

正確的accept，accept 要考慮 2 個問題

(1) 阻塞模式 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 模式下 的正確使用方式為：

1. while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote,   
2.                 (size_t *)&addrlen)) > 0) {  
3.     handle_client(conn_sock);  
4. }  
5. if (conn_sock == -1) {  
6.     if (errno != EAGAIN && errno != ECONNABORTED   
7.             && errno != EPROTO && errno != EINTR)   
8.         perror("accept");  
9. }  

一道騰訊後臺開發的面試題

使用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伺服器程式碼:

1. #include <sys/socket.h>
2. #include <sys/wait.h>
3. #include <netinet/in.h>
4. #include <netinet/tcp.h>
5. #include <sys/epoll.h>
6. #include <sys/sendfile.h>
7. #include <sys/stat.h>
8. #include <unistd.h>
9. #include <stdio.h>
10. #include <stdlib.h>
11. #include <string.h>
12. #include <strings.h>
13. #include <fcntl.h>
14. #include <errno.h> 
15. #define MAX_EVENTS 10
16. #define PORT 8080
17. //設定socket連線為非阻塞模式
18. void setnonblocking(int sockfd) {  
19.     int opts;  
20.     opts = fcntl(sockfd, F_GETFL);  
21.     if(opts < 0) {  
22.         perror("fcntl(F_GETFL)\n");  
23.         exit(1);  
24.     }  
25.     opts = (opts | O_NONBLOCK);  
26.     if(fcntl(sockfd, F_SETFL, opts) < 0) {  
27.         perror("fcntl(F_SETFL)\n");  
28.         exit(1);  
29.     }  
30. }  
31. int main(){  
32.     struct epoll_event ev, events[MAX_EVENTS];  
33.     int addrlen, listenfd, conn_sock, nfds, epfd, fd, i, nread, n;  
34.     struct sockaddr_in local, remote;  
35.     char buf[BUFSIZ];  
36.     //建立listen socket
37.     if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {  
38.         perror("sockfd\n");  
39.         exit(1);  
40.     }  
41.     setnonblocking(listenfd);  
42.     bzero(&local, sizeof(local));  
43.     local.sin_family = AF_INET;  
44.     local.sin_addr.s_addr = htonl(INADDR_ANY);;  
45.     local.sin_port = htons(PORT);  
46.     if( bind(listenfd, (struct sockaddr *) &local, sizeof(local)) < 0) {  
47.         perror("bind\n");  
48.         exit(1);  
49.     }  
50.     listen(listenfd, 20);  
51.     epfd = epoll_create(MAX_EVENTS);  
52.     if (epfd == -1) {  
53.         perror("epoll_create");  
54.         exit(EXIT_FAILURE);  
55.     }  
56.     ev.events = EPOLLIN;  
57.     ev.data.fd = listenfd;  
58.     if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {  
59.         perror("epoll_ctl: listen_sock");  
60.         exit(EXIT_FAILURE);  
61.     }  
62.     for (;;) {  
63.         nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);  
64.         if (nfds == -1) {  
65.             perror("epoll_pwait");  
66.             exit(EXIT_FAILURE);  
67.         }  
68.         for (i = 0; i < nfds; ++i) {  
69.             fd = events[i].data.fd;  
70.             if (fd == listenfd) {  
71.                 while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote,   
72.                                 (size_t *)&addrlen)) > 0) {  
73.                     setnonblocking(conn_sock);  
74.                     ev.events = EPOLLIN | EPOLLET;  
75.                     ev.data.fd = conn_sock;  
76.                     if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock,  
77.                                 &ev) == -1) {  
78.                         perror("epoll_ctl: add");  
79.                         exit(EXIT_FAILURE);  
80.                     }  
81.                 }  
82.                 if (conn_sock == -1) {  
83.                     if (errno != EAGAIN && errno != ECONNABORTED   
84.                             && errno != EPROTO && errno != EINTR)   
85.                         perror("accept");  
86.                 }  
87.                 continue;  
88.             }    
89.             if (events[i].events & EPOLLIN) {  
90.                 n = 0;  
91.                 while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {  
92.                     n += nread;  
93.                 }  
94.                 if (nread == -1 && errno != EAGAIN) {  
95.                     perror("read error");  
96.                 }  
97.                 ev.data.fd = fd;  
98.                 ev.events = events[i].events | EPOLLOUT;  
99.                 if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {  
100.                     perror("epoll_ctl: mod");  
101.                 }  
102.             }  
103.             if (events[i].events & EPOLLOUT) {  
104.                 sprintf(buf, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\nHello World", 11);  
105.                 int nwrite, data_size = strlen(buf);  
106.                 n = data_size;  
107.                 while (n > 0) {  
108.                     nwrite = write(fd, buf + data_size - n, n);  
109.                     if (nwrite < n) {  
110.                         if (nwrite == -1 && errno != EAGAIN) {  
111.                             perror("write error");  
112.                         }  
113.                         break;  
114.                     }  
115.                     n -= nwrite;  
116.                 }  
117.                 close(fd);  
118.             }  
119.         }  
120.     }  
121.     return 0;  
122. }