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