問題：如果我們先前創建的幾個進程承載不了目前快速發展的業務的話，是不是還得增加進程數？我們都知道系統創建進程是需要消耗大量資源的，所以這樣就會導致系統資源不足的情況。

那么有沒有一種方式可以讓一個進程同時為多個客戶端端提供服務？

接下來要講的IO復用技術就是對于上述問題的最好解答。

對于IO復用，我們可以通過一個例子來很好的理解它。（

例子來自于《TCP/IP網絡編程》）

某教室有10名學生和1名老師，這些學生上課會不停的提問，所以一個老師處理不了這么多的問題。那么學校為每個學生都配一名老師，也就是這個教室目前有10名老師。此后，只要有新的轉校生，那么就會為這個學生專門分配一個老師，因為轉校生也喜歡提問題。如果把以上例子中的學生比作客戶端，那么老師就是負責進行數據交換的服務端。則該例子可以比作是多進程的方式。

后來有一天，來了一位具有超能力的老師，這位老師回答問題非常迅速，并且可以應對所有的問題。而這位老師采用的方式是學生提問前必須先舉手，確認舉手學生后在回答問題。則現在的情況就是IO復用。

目前的常用的IO復用模型有三種：select，poll，epoll。
(1)select==>時間復雜度O(n)

它僅僅知道了，有I/O事件發生了，卻并不知道是哪那幾個流（可能有一個，多個，甚至全部），我們只能無差別輪詢所有流，找出能讀出數據，或者寫入數據的流，對他們進行操作。所以select具有O(n)的無差別輪詢復雜度，同時處理的流越多，無差別輪詢時間就越長。

(2)poll==>時間復雜度O(n)

poll本質上和select沒有區別，它將用戶傳入的數組拷貝到內核空間，然后查詢每個fd對應的設備狀態， 但是它沒有最大連接數的限制，原因是它是基于鏈表來存儲的.

(3)epoll==>時間復雜度O(1)

epoll可以理解為event poll，不同于忙輪詢和無差別輪詢，epoll會把哪個流發生了怎樣的I/O事件通知我們。所以我們說epoll實際上是事件驅動（每個事件關聯上fd）的，此時我們對這些流的操作都是有意義的。（復雜度降低到了O(1)）

select，poll，epoll都是IO多路復用的機制。I/O多路復用就通過一種機制，可以監視多個描述符，一旦某個描述符就緒（一般是讀就緒或者寫就緒），能夠通知程序進行相應的讀寫操作。但select，poll，epoll本質上都是同步I/O，因為他們都需要在讀寫事件就緒后自己負責進行讀寫，也就是說這個讀寫過程是阻塞的，而異步I/O則無需自己負責進行讀寫，異步I/O的實現會負責把數據從內核拷貝到用戶空間。 ?

epoll跟select都能提供多路I/O復用的解決方案。在現在的Linux內核里有都能夠支持，其中epoll是Linux所特有，而select則應該是POSIX所規定，一般操作系統均有實現

select：

select的調用過程如下所示：

（1）使用copy_from_user從用戶空間拷貝fd_set到內核空間

（2）注冊回調函數__pollwait

（3）遍歷所有fd，調用其對應的poll方法（對于socket，這個poll方法是sock_poll，sock_poll根據情況會調用到tcp_poll,udp_poll或者datagram_poll）

（4）以tcp_poll為例，其核心實現就是__pollwait，也就是上面注冊的回調函數。

（5）__pollwait的主要工作就是把current（當前進程）掛到設備的等待隊列中，不同的設備有不同的等待隊列，對于tcp_poll來說，其等待隊列是sk->sk_sleep（注意把進程掛到等待隊列中并不代表進程已經睡眠了）。在設備收到一條消息（網絡設備）或填寫完文件數據（磁盤設備）后，會喚醒設備等待隊列上睡眠的進程，這時current便被喚醒了。

（6）poll方法返回時會返回一個描述讀寫操作是否就緒的mask掩碼，根據這個mask掩碼給fd_set賦值。

（7）如果遍歷完所有的fd，還沒有返回一個可讀寫的mask掩碼，則會調用schedule_timeout是調用select的進程（也就是current）進入睡眠。當設備驅動發生自身資源可讀寫后，會喚醒其等待隊列上睡眠的進程。如果超過一定的超時時間（schedule_timeout指定），還是沒人喚醒，則調用select的進程會重新被喚醒獲得CPU，進而重新遍歷fd，判斷有沒有就緒的fd。

（8）把fd_set從內核空間拷貝到用戶空間。

select本質上是通過設置或者檢查存放fd標志位的數據結構來進行下一步處理。這樣所帶來的缺點是：

1、 單個進程可監視的fd數量被限制，即能監聽端口的大小有限。

? ? ? 一般來說這個數目和系統內存關系很大，具體數目可以cat /proc/sys/fs/file-max察看。32位機默認是1024個。64位機默認是2048.

2、 對socket進行掃描時是線性掃描，即采用輪詢的方法，效率較低：

? ? ? ?當套接字比較多的時候，每次select()都要通過遍歷FD_SETSIZE個Socket來完成調度,不管哪個Socket是活躍的,都遍歷一遍。這會浪費很多CPU時間。如果能給套接字注冊某個回調函數，當他們活躍時，自動完成相關操作，那就避免了輪詢，這正是epoll與kqueue做的。

（1）每次調用select，都需要把fd集合從用戶態拷貝到內核態，這個開銷在fd很多時會很大

（2）同時每次調用select都需要在內核遍歷傳遞進來的所有fd，這個開銷在fd很多時也很大

3、需要維護一個用來存放大量fd的數據結構，這樣會使得用戶空間和內核空間在傳遞該結構時復制開銷大

poll：

poll的實現和select非常相似，只是描述fd集合的方式不同，poll使用pollfd結構而不是select的fd_set結構，其他的都差不多,管理多個描述符也是進行輪詢，根據描述符的狀態進行處理，但是poll沒有最大文件描述符數量的限制。poll和select同樣存在一個缺點就是，包含大量文件描述符的數組被整體復制于用戶態和內核的地址空間之間，而不論這些文件描述符是否就緒，它的開銷隨著文件描述符數量的增加而線性增大。

poll本質上和select沒有區別，它將用戶傳入的數組拷貝到內核空間，然后查詢每個fd對應的設備狀態，如果設備就緒則在設備等待隊列中加入一項并繼續遍歷，如果遍歷完所有fd后沒有發現就緒設備，則掛起當前進程，直到設備就緒或者主動超時，被喚醒后它又要再次遍歷fd。這個過程經歷了多次無謂的遍歷。

它沒有最大連接數的限制，原因是它是基于鏈表來存儲的，但是同樣有一個缺點：

1、大量的fd的數組被整體復制于用戶態和內核地址空間之間，而不管這樣的復制是不是有意義。 ? ? ? ? ? ? ? ? ??

2、poll還有一個特點是“水平觸發”，如果報告了fd后，沒有被處理，那么下次poll時會再次報告該fd。

epoll:

epoll有EPOLL LT和EPOLL ET兩種觸發模式，LT是默認的模式，ET是“高速”模式。LT模式下，只要這個fd還有數據可讀，每次 epoll_wait都會返回它的事件，提醒用戶程序去操作，而在ET（邊緣觸發）模式中，它只會提示一次，直到下次再有數據流入之前都不會再提示了，無 論fd中是否還有數據可讀。所以在ET模式下，read一個fd的時候一定要把它的buffer讀光，也就是說一直讀到read的返回值小于請求值，或者 遇到EAGAIN錯誤。還有一個特點是，epoll使用“事件”的就緒通知方式，通過epoll_ctl注冊fd，一旦該fd就緒，內核就會采用類似callback的回調機制來激活該fd，epoll_wait便可以收到通知。

epoll為什么要有EPOLL ET觸發模式？

如果采用EPOLL LT模式的話，系統中一旦有大量你不需要讀寫的就緒文件描述符，它們每次調用epoll_wait都會返回，這樣會大大降低處理程序檢索自己關心的就緒文件描述符的效率.。而采用EPOLL ET這種邊沿觸發模式的話，當被監控的文件描述符上有可讀寫事件發生時，epoll_wait()會通知處理程序去讀寫。如果這次沒有把數據全部讀寫完(如讀寫緩沖區太小)，那么下次調用epoll_wait()時，它不會通知你，也就是它只會通知你一次，直到該文件描述符上出現第二次可讀寫事件才會通知你！！！這種模式比水平觸發效率高，系統不會充斥大量你不關心的就緒文件描述符。

epoll的優點：

1、沒有最大并發連接的限制，能打開的FD的上限遠大于1024（1G的內存上能監聽約10萬個端口）；
2、效率提升，不是輪詢的方式，不會隨著FD數目的增加效率下降。只有活躍可用的FD才會調用callback函數；
即Epoll最大的優點就在于它只管你“活躍”的連接，而跟連接總數無關，因此在實際的網絡環境中，Epoll的效率就會遠遠高于select和poll。

3、 內存拷貝，利用mmap()文件映射內存加速與內核空間的消息傳遞；即epoll使用mmap減少復制開銷。

epoll既然是對select和poll的改進，就應該能避免上述缺點。那epoll都是怎么解決的呢？在此之前，我們先看一下epoll和select和poll的調用接口上的不同，select和poll都只提供了一個函數——select或者poll函數。而epoll提供了三個函數，epoll_create,epoll_ctl和epoll_wait，epoll_create是創建一個epoll句柄；epoll_ctl是注冊要監聽的事件類型；epoll_wait則是等待事件的產生。

　　對于第一個缺點，epoll的解決方案在epoll_ctl函數中。每次注冊新的事件到epoll句柄中時（在epoll_ctl中指定EPOLL_CTL_ADD），會把所有的fd拷貝進內核，而不是在epoll_wait的時候重復拷貝。epoll保證了每個fd在整個過程中只會拷貝一次。

　　對于第二個缺點，epoll的解決方案不像select或poll一樣每次都把current輪流加入fd對應的設備等待隊列中，而只在epoll_ctl時把current掛一遍（這一遍必不可少）并為每個fd指定一個回調函數，當設備就緒，喚醒等待隊列上的等待者時，就會調用這個回調函數，而這個回調函數會把就緒的fd加入一個就緒鏈表）。epoll_wait的工作實際上就是在這個就緒鏈表中查看有沒有就緒的fd（利用schedule_timeout()實現睡一會，判斷一會的效果，和select實現中的第7步是類似的）。

　　epoll沒有FD個數這個限制，它所支持的FD上限是最大可以打開文件的數目，這個數字一般遠大于2048,舉個例子,在1GB內存的機器上大約是10萬左右，具體數目可以cat /proc/sys/fs/file-max察看,一般來說這個數目和系統內存關系很大。

select、poll、epoll 區別總結：
1、支持一個進程所能打開的最大連接數

select：單個進程所能打開的最大連接數有FD_SETSIZE宏定義，其大小是32個整數的大小（在32位的機器上，大小就是3232，同理64位機器上FD_SETSIZE為3264），當然我們可以對進行修改，然后重新編譯內核，但是性能可能會受到影響，這需要進一步的測試。

poll：poll本質上和select沒有區別，但是它沒有最大連接數的限制，原因是它是基于鏈表來存儲的。

epoll：雖然連接數有上限，但是很大，1G內存的機器上可以打開10萬左右的連接，2G內存的機器可以打開20萬左右的連接。

2、FD劇增后帶來的IO效率問題

select：因為每次調用時都會對連接進行線性遍歷，所以隨著FD的增加會造成遍歷速度慢的“線性下降性能問題”。

poll：同上

epoll：因為epoll內核中實現是根據每個fd上的callback函數來實現的，只有活躍的socket才會主動調用callback，所以在活躍socket較少的情況下，使用epoll沒有前面兩者的線性下降的性能問題，但是所有socket都很活躍的情況下，可能會有性能問題。

3、 消息傳遞方式

select：內核需要將消息傳遞到用戶空間，都需要內核拷貝動作

poll：同上

epoll：epoll通過內核和用戶空間共享一塊內存來實現的。

總結：

綜上，在選擇select，poll，epoll時要根據具體的使用場合以及這三種方式的自身特點。

1、表面上看epoll的性能最好，但是在連接數少并且連接都十分活躍的情況下，select和poll的性能可能比epoll好，畢竟epoll的通知機制需要很多函數回調。

select，poll實現需要自己不斷輪詢所有fd集合，直到設備就緒，期間可能要睡眠和喚醒多次交替。而epoll其實也需要調用epoll_wait不斷輪詢就緒鏈表，期間也可能多次睡眠和喚醒交替，但是它是設備就緒時，調用回調函數，把就緒fd放入就緒鏈表中，并喚醒在epoll_wait中進入睡眠的進程。雖然都要睡眠和交替，但是select和poll在“醒著”的時候要遍歷整個fd集合，而epoll在“醒著”的時候只要判斷一下就緒鏈表是否為空就行了，這節省了大量的CPU時間。這就是回調機制帶來的性能提升。

2、select低效是因為每次它都需要輪詢。但低效也是相對的，視情況而定，也可通過良好的設計改善?

select，poll每次調用都要把fd集合從用戶態往內核態拷貝一次，并且要把current往設備等待隊列中掛一次，而epoll只要一次拷貝，而且把current往等待隊列上掛也只掛一次（在epoll_wait的開始，注意這里的等待隊列并不是設備等待隊列，只是一個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的高效。

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

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

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

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

// ??
// a simple echo server using epoll in linux ?
// ? ?
// 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; ?
} ??
?
————————————————
版權聲明：本文為CSDN博主「panamera12」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/wteruiycbqqvwt/article/details/90299610

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的深入理解select、poll和epoll及区别的全部內容，希望文章能夠幫你解決所遇到的問題。

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