LT 和 ET本質的區別是：

LT模式狀態時，主線程正在epoll_wait等待事件時，請求到了，epoll_wait返回后沒有去處理請求(recv)，那么下次epoll_wait時此請求還是會返回（立刻返回了）；而ET模式狀態下，這次沒處理，下次epoll_wait時將不返回（所以我們應該每次一定要處理），可見很大程度降低了epoll的觸發次數（記住這句話先）

?

Level_triggered(水平觸發)：當被監控的文件描述符上有可讀寫事件發生時，epoll_wait()會通知處理程序去讀寫。如果這次沒有把數據一次性全部讀寫完(如讀寫緩沖區太小)，那么下次調用 epoll_wait()時，它還會通知你在上沒讀寫完的文件描述符上繼續讀寫，當然如果你一直不去讀寫，它會一直通知你！！！如果系統中有大量你不需要讀寫的就緒文件描述符，而它們每次都會返回，這樣會大大降低處理程序檢索自己關心的就緒文件描述符的效率！！！

Edge_triggered(邊緣觸發)：當被監控的文件描述符上有可讀寫事件發生時，epoll_wait()會通知處理程序去讀寫。如果這次沒有把數據全部讀寫完(如讀寫緩沖區太小)，那么下次調用epoll_wait()時，它不會通知你，也就是它只會通知你一次，直到該文件描述符上出現第二次可讀寫事件才會通知你！！！這種模式比水平觸發效率高，系統不會充斥大量你不關心的就緒文件描述符！！！

?

在linux 沒有實現epoll事件驅動機制之前，我們一般選擇用select或者poll等IO多路復用的方法來實現并發服務程序。在大數據、高并發、集群等一些名詞唱得火熱之年代，select和poll的用武之地越來越有限，風頭已經被epoll占盡。

本文便來介紹epoll的實現機制，并附帶講解一下select和poll。通過對比其不同的實現機制，真正理解為何epoll能實現高并發。

select()和poll() IO多路復用模型

select的缺點：

單個進程能夠監視的文件描述符的數量存在最大限制，通常是1024，當然可以更改數量，但由于select采用輪詢的方式掃描文件描述符，文件描述符數量越多，性能越差；(在linux內核頭文件中，有這樣的定義：#define __FD_SETSIZE??? 1024)

內核 / 用戶空間內存拷貝問題，select需要復制大量的句柄數據結構，產生巨大的開銷；

select返回的是含有整個句柄的數組，應用程序需要遍歷整個數組才能發現哪些句柄發生了事件；

select的觸發方式是水平觸發，應用程序如果沒有完成對一個已經就緒的文件描述符進行IO操作，那么之后每次select調用還是會將這些文件描述符通知進程。

相比select模型，poll使用鏈表保存文件描述符，因此沒有了監視文件數量的限制，但其他三個缺點依然存在。

拿select模型為例，假設我們的服務器需要支持100萬的并發連接，則在__FD_SETSIZE 為1024的情況下，則我們至少需要開辟1k個進程才能實現100萬的并發連接。除了進程間上下文切換的時間消耗外，從內核/用戶空間大量的無腦內存拷貝、數組輪詢等，是系統難以承受的。因此，基于select模型的服務器程序，要達到10萬級別的并發訪問，是一個很難完成的任務。

因此，該epoll上場了。

epoll IO多路復用模型實現機制

由于epoll的實現機制與select/poll機制完全不同，上面所說的 select的缺點在epoll上不復存在。

設想一下如下場景：有100萬個客戶端同時與一個服務器進程保持著TCP連接。而每一時刻，通常只有幾百上千個TCP連接是活躍的(事實上大部分場景都是這種情況)。如何實現這樣的高并發？

在select/poll時代，服務器進程每次都把這100萬個連接告訴操作系統(從用戶態復制句柄數據結構到內核態)，讓操作系統內核去查詢這些套接字上是否有事件發生，輪詢完后，再將句柄數據復制到用戶態，讓服務器應用程序輪詢處理已發生的網絡事件，這一過程資源消耗較大，因此，select/poll一般只能處理幾千的并發連接。

epoll的設計和實現與select完全不同。epoll通過在Linux內核中申請一個簡易的文件系統(文件系統一般用什么數據結構實現？B+樹)。把原先的select/poll調用分成了3個部分：

1）調用epoll_create()建立一個epoll對象(在epoll文件系統中為這個句柄對象分配資源)

2）調用epoll_ctl向epoll對象中添加這100萬個連接的套接字

3）調用epoll_wait收集發生的事件的連接

如此一來，要實現上面說是的場景，只需要在進程啟動時建立一個epoll對象，然后在需要的時候向這個epoll對象中添加或者刪除連接。同時，epoll_wait的效率也非常高，因為調用epoll_wait時，并沒有一股腦的向操作系統復制這100萬個連接的句柄數據，內核也不需要去遍歷全部的連接。

下面來看看Linux內核具體的epoll機制實現思路。

當某一進程調用epoll_create方法時，Linux內核會創建一個eventpoll結構體，這個結構體中有兩個成員與epoll的使用方式密切相關。eventpoll結構體如下所示：

struct eventpoll{
? ? ....
? ? /*紅黑樹的根節點，這顆樹中存儲著所有添加到epoll中的需要監控的事件*/
? ? struct rb_root ?rbr;
? ? /*雙鏈表中則存放著將要通過epoll_wait返回給用戶的滿足條件的事件*/
? ? struct list_head rdlist;
? ? ....
};

每一個epoll對象都有一個獨立的eventpoll結構體，用于存放通過epoll_ctl方法向epoll對象中添加進來的事件。這些事件都會掛載在紅黑樹中，如此，重復添加的事件就可以通過紅黑樹而高效的識別出來(紅黑樹的插入時間效率是lgn，其中n為樹的高度)。

而所有添加到epoll中的事件都會與設備(網卡)驅動程序建立回調關系，也就是說，當相應的事件發生時會調用這個回調方法。這個回調方法在內核中叫ep_poll_callback,它會將發生的事件添加到rdlist雙鏈表中。

在epoll中，對于每一個事件，都會建立一個epitem結構體，如下所示：

struct epitem{
? ? struct rb_node ?rbn;//紅黑樹節點
? ? struct list_head ? ?rdllink;//雙向鏈表節點
? ? struct epoll_filefd ?ffd; ?//事件句柄信息
? ? struct eventpoll *ep; ? ?//指向其所屬的eventpoll對象
? ? struct epoll_event event; //期待發生的事件類型
}

當調用epoll_wait檢查是否有事件發生時，只需要檢查eventpoll對象中的rdlist雙鏈表中是否有epitem元素即可。如果rdlist不為空，則把發生的事件復制到用戶態，同時將事件數量返回給用戶。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?epoll數據結構示意圖

從上面的講解可知：通過紅黑樹和雙鏈表數據結構，并結合回調機制，造就了epoll的高效。

OK，講解完了Epoll的機理，我們便能很容易掌握epoll的用法了。一句話描述就是：三步曲。

第一步：epoll_create()系統調用。此調用返回一個句柄，之后所有的使用都依靠這個句柄來標識。

第二步：epoll_ctl()系統調用。通過此調用向epoll對象中添加、刪除、修改感興趣的事件，返回0標識成功，返回-1表示失敗。

第三部：epoll_wait()系統調用。通過此調用收集收集在epoll監控中已經發生的事件。

最后，附上一個epoll編程實例。(作者為sparkliang)

// ??
// a simple echo server using epoll in linux ?
// ??
// 2009-11-05 ?
// 2013-03-22:修改了幾個問題，1是/n格式問題，2是去掉了原代碼不小心加上的ET模式;
// 本來只是簡單的示意程序，決定還是加上 recv/send時的buffer偏移
// by sparkling ?
// ??
#include <sys/socket.h> ?
#include <sys/epoll.h> ?
#include <netinet/in.h> ?
#include <arpa/inet.h> ?
#include <fcntl.h> ?
#include <unistd.h> ?
#include <stdio.h> ?
#include <errno.h> ?
#include <iostream> ?
using namespace std; ?
#define MAX_EVENTS 500 ?
struct myevent_s ?
{ ?
? ? int fd; ?
? ? void (*call_back)(int fd, int events, void *arg); ?
? ? int events; ?
? ? void *arg; ?
? ? int status; // 1: in epoll wait list, 0 not in ?
? ? char buff[128]; // recv data buffer ?
? ? int len, s_offset; ?
? ? long last_active; // last active time ?
}; ?
// set event ?
void EventSet(myevent_s *ev, int fd, void (*call_back)(int, int, void*), void *arg) ?
{ ?
? ? ev->fd = fd; ?
? ? ev->call_back = call_back; ?
? ? ev->events = 0; ?
? ? ev->arg = arg; ?
? ? ev->status = 0;
? ? bzero(ev->buff, sizeof(ev->buff));
? ? ev->s_offset = 0; ?
? ? ev->len = 0;
? ? ev->last_active = time(NULL); ?
} ?
// add/mod an event to epoll ?
void EventAdd(int epollFd, int events, myevent_s *ev) ?
{ ?
? ? struct epoll_event epv = {0, {0}}; ?
? ? int op; ?
? ? epv.data.ptr = ev; ?
? ? epv.events = ev->events = events; ?
? ? if(ev->status == 1){ ?
? ? ? ? op = EPOLL_CTL_MOD; ?
? ? } ?
? ? else{ ?
? ? ? ? op = EPOLL_CTL_ADD; ?
? ? ? ? ev->status = 1; ?
? ? } ?
? ? if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0) ?
? ? ? ? printf("Event Add failed[fd=%d], evnets[%d]\n", ev->fd, events); ?
? ? else ?
? ? ? ? printf("Event Add OK[fd=%d], op=%d, evnets[%0X]\n", ev->fd, op, events); ?
} ?
// delete an event from epoll ?
void EventDel(int epollFd, myevent_s *ev) ?
{ ?
? ? struct epoll_event epv = {0, {0}}; ?
? ? if(ev->status != 1) return; ?
? ? epv.data.ptr = ev; ?
? ? ev->status = 0;
? ? epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv); ?
} ?
int g_epollFd; ?
myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd ?
void RecvData(int fd, int events, void *arg); ?
void SendData(int fd, int events, void *arg); ?
// accept new connections from clients ?
void AcceptConn(int fd, int events, void *arg) ?
{ ?
? ? struct sockaddr_in sin; ?
? ? socklen_t len = sizeof(struct sockaddr_in); ?
? ? int nfd, i; ?
? ? // accept ?
? ? if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1) ?
? ? { ?
? ? ? ? if(errno != EAGAIN && errno != EINTR) ?
? ? ? ? { ?
? ? ? ? }
? ? ? ? printf("%s: accept, %d", __func__, errno); ?
? ? ? ? return; ?
? ? } ?
? ? do ?
? ? { ?
? ? ? ? for(i = 0; i < MAX_EVENTS; i++) ?
? ? ? ? { ?
? ? ? ? ? ? if(g_Events[i].status == 0) ?
? ? ? ? ? ? { ?
? ? ? ? ? ? ? ? break; ?
? ? ? ? ? ? } ?
? ? ? ? } ?
? ? ? ? if(i == MAX_EVENTS) ?
? ? ? ? { ?
? ? ? ? ? ? printf("%s:max connection limit[%d].", __func__, MAX_EVENTS); ?
? ? ? ? ? ? break; ?
? ? ? ? } ?
? ? ? ? // set nonblocking
? ? ? ? int iret = 0;
? ? ? ? if((iret = fcntl(nfd, F_SETFL, O_NONBLOCK)) < 0)
? ? ? ? {
? ? ? ? ? ? printf("%s: fcntl nonblocking failed:%d", __func__, iret);
? ? ? ? ? ? break;
? ? ? ? }
? ? ? ? // add a read event for receive data ?
? ? ? ? EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]); ?
? ? ? ? EventAdd(g_epollFd, EPOLLIN, &g_Events[i]); ?
? ? }while(0); ?
? ? printf("new conn[%s:%d][time:%d], pos[%d]\n", inet_ntoa(sin.sin_addr),
? ? ? ? ? ? ntohs(sin.sin_port), g_Events[i].last_active, i); ?
} ?
// receive data ?
void RecvData(int fd, int events, void *arg) ?
{ ?
? ? struct myevent_s *ev = (struct myevent_s*)arg; ?
? ? int len; ?
? ? // receive data
? ? len = recv(fd, ev->buff+ev->len, sizeof(ev->buff)-1-ev->len, 0); ? ?
? ? EventDel(g_epollFd, ev);
? ? if(len > 0)
? ? {
? ? ? ? ev->len += len;
? ? ? ? ev->buff[len] = '\0'; ?
? ? ? ? printf("C[%d]:%s\n", fd, ev->buff); ?
? ? ? ? // change to send event ?
? ? ? ? EventSet(ev, fd, SendData, ev); ?
? ? ? ? EventAdd(g_epollFd, EPOLLOUT, ev); ?
? ? } ?
? ? else if(len == 0) ?
? ? { ?
? ? ? ? close(ev->fd); ?
? ? ? ? printf("[fd=%d] pos[%d], closed gracefully.\n", fd, ev-g_Events); ?
? ? } ?
? ? else ?
? ? { ?
? ? ? ? close(ev->fd); ?
? ? ? ? printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno)); ?
? ? } ?
} ?
// send data ?
void SendData(int fd, int events, void *arg) ?
{ ?
? ? struct myevent_s *ev = (struct myevent_s*)arg; ?
? ? int len; ?
? ? // send data ?
? ? len = send(fd, ev->buff + ev->s_offset, ev->len - ev->s_offset, 0);
? ? if(len > 0) ?
? ? {
? ? ? ? printf("send[fd=%d], [%d<->%d]%s\n", fd, len, ev->len, ev->buff);
? ? ? ? ev->s_offset += len;
? ? ? ? if(ev->s_offset == ev->len)
? ? ? ? {
? ? ? ? ? ? // change to receive event
? ? ? ? ? ? EventDel(g_epollFd, ev); ?
? ? ? ? ? ? EventSet(ev, fd, RecvData, ev); ?
? ? ? ? ? ? EventAdd(g_epollFd, EPOLLIN, ev); ?
? ? ? ? }
? ? } ?
? ? else ?
? ? { ?
? ? ? ? close(ev->fd); ?
? ? ? ? EventDel(g_epollFd, ev); ?
? ? ? ? printf("send[fd=%d] error[%d]\n", fd, errno); ?
? ? } ?
} ?
void InitListenSocket(int epollFd, short port) ?
{ ?
? ? int listenFd = socket(AF_INET, SOCK_STREAM, 0); ?
? ? fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking ?
? ? printf("server listen fd=%d\n", listenFd); ?
? ? EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]); ?
? ? // add listen socket ?
? ? EventAdd(epollFd, EPOLLIN, &g_Events[MAX_EVENTS]); ?
? ? // bind & listen ?
? ? sockaddr_in sin; ?
? ? bzero(&sin, sizeof(sin)); ?
? ? sin.sin_family = AF_INET; ?
? ? sin.sin_addr.s_addr = INADDR_ANY; ?
? ? sin.sin_port = htons(port); ?
? ? bind(listenFd, (const sockaddr*)&sin, sizeof(sin)); ?
? ? listen(listenFd, 5); ?
} ?
int main(int argc, char **argv) ?
{ ?
? ? unsigned short port = 12345; // default port ?
? ? if(argc == 2){ ?
? ? ? ? port = atoi(argv[1]); ?
? ? } ?
? ? // create epoll ?
? ? g_epollFd = epoll_create(MAX_EVENTS); ?
? ? if(g_epollFd <= 0) printf("create epoll failed.%d\n", g_epollFd); ?
? ? // create & bind listen socket, and add to epoll, set non-blocking ?
? ? InitListenSocket(g_epollFd, port); ?
? ? // event loop ?
? ? struct epoll_event events[MAX_EVENTS]; ?
? ? printf("server running:port[%d]\n", port); ?
? ? int checkPos = 0; ?
? ? while(1){ ?
? ? ? ? // a simple timeout check here, every time 100, better to use a mini-heap, and add timer event ?
? ? ? ? long now = time(NULL); ?
? ? ? ? for(int i = 0; i < 100; i++, checkPos++) // doesn't check listen fd ?
? ? ? ? { ?
? ? ? ? ? ? if(checkPos == MAX_EVENTS) checkPos = 0; // recycle ?
? ? ? ? ? ? if(g_Events[checkPos].status != 1) continue; ?
? ? ? ? ? ? long duration = now - g_Events[checkPos].last_active; ?
? ? ? ? ? ? if(duration >= 60) // 60s timeout ?
? ? ? ? ? ? { ?
? ? ? ? ? ? ? ? close(g_Events[checkPos].fd); ?
? ? ? ? ? ? ? ? printf("[fd=%d] timeout[%d--%d].\n", g_Events[checkPos].fd, g_Events[checkPos].last_active, now); ?
? ? ? ? ? ? ? ? EventDel(g_epollFd, &g_Events[checkPos]); ?
? ? ? ? ? ? } ?
? ? ? ? } ?
? ? ? ? // wait for events to happen ?
? ? ? ? int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000); ?
? ? ? ? if(fds < 0){ ?
? ? ? ? ? ? printf("epoll_wait error, exit\n"); ?
? ? ? ? ? ? break; ?
? ? ? ? } ?
? ? ? ? for(int i = 0; i < fds; i++){ ?
? ? ? ? ? ? myevent_s *ev = (struct myevent_s*)events[i].data.ptr; ?
? ? ? ? ? ? if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event ?
? ? ? ? ? ? { ?
? ? ? ? ? ? ? ? ev->call_back(ev->fd, events[i].events, ev->arg); ?
? ? ? ? ? ? } ?
? ? ? ? ? ? if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event ?
? ? ? ? ? ? { ?
? ? ? ? ? ? ? ? ev->call_back(ev->fd, events[i].events, ev->arg); ?
? ? ? ? ? ? } ?
? ? ? ? } ?
? ? } ?
? ? // free resource ?
? ? return 0; ?
} ??
?

總結

以上是生活随笔為你收集整理的高并发网络编程之epoll(个人遇到最好理解的一篇文章、易懂)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。