在一個非阻塞的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
正確的讀:
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 存在的問題
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 模式下 的正確使用方式爲:
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");
}
一道騰訊後臺開發的面試題
使用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服務器代碼:
#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;
}