Linux下select, poll和epoll IO模型的詳解

一）.Epoll 介紹

Epoll 可是當前在 Linux 下開發大規模併發網絡程序的熱門人選， Epoll 在 Linux2.6 內核中正式引入，和 select 相似，其實都 I/O 多路複用技術而已 ，並沒有什麼神祕的。其實在 Linux 下設計併發網絡程序，向來不缺少方法，比如典型的 Apache 模型（ Process Per Connection ，簡稱 PPC ）， TPC （ Thread Per Connection ）模型，以及 select 模型和 poll 模型，那爲何還要再引入 Epoll 這個東東呢？那還是有得說說的 …

二）. 常用模型的缺點

如果不擺出來其他模型的缺點，怎麼能對比出 Epoll 的優點呢。

① PPC/TPC 模型

這兩種模型思想類似，就是讓每一個到來的連接一邊自己做事去，別再來煩我 。只是 PPC 是爲它開了一個進程，而 TPC 開了一個線程。可是別煩我是有代價的，它要時間和空間啊，連接多了之後，那麼多的進程 / 線程切換，這開銷就上來了；因此這類模型能接受的最大連接數都不會高，一般在幾百個左右。

② select 模型

1. 最大併發數限制，因爲一個進程所打開的 FD （文件描述符）是有限制的，由 FD_SETSIZE 設置，默認值是 1024/2048 ，因此 Select 模型的最大併發數就被相應限制了。自己改改這個 FD_SETSIZE ？想法雖好，可是先看看下面吧 …

2. 效率問題， select 每次調用都會線性掃描全部的 FD 集合，這樣效率就會呈現線性下降，把 FD_SETSIZE 改大的後果就是，大家都慢慢來，什麼？都超時了。

3. 內核 / 用戶空間內存拷貝問題，如何讓內核把 FD 消息通知給用戶空間呢？在這個問題上 select 採取了內存拷貝方法。

總結爲：1.連接數受限 2.查找配對速度慢 3.數據由內核拷貝到用戶態

③ poll 模型

基本上效率和 select 是相同的， select 缺點的 2 和 3 它都沒有改掉。

三）. Epoll 的提升

把其他模型逐個批判了一下，再來看看 Epoll 的改進之處吧，其實把 select 的缺點反過來那就是 Epoll 的優點了。

①. Epoll 沒有最大併發連接的限制，上限是最大可以打開文件的數目，這個數字一般遠大於 2048, 一般來說這個數目和系統內存關係很大 ，具體數目可以 cat /proc/sys/fs/file-max 察看。

②. 效率提升， Epoll 最大的優點就在於它只管你“活躍”的連接 ，而跟連接總數無關，因此在實際的網絡環境中， Epoll 的效率就會遠遠高於 select 和 poll 。

③. 內存拷貝， Epoll 在這點上使用了“共享內存 ”，這個內存拷貝也省略了。

四）. Epoll 爲什麼高效

Epoll 的高效和其數據結構的設計是密不可分的，這個下面就會提到。

首先回憶一下 select 模型，當有 I/O 事件到來時， select 通知應用程序有事件到了快去處理，而應用程序必須輪詢所有的 FD 集合，測試每個 FD 是否有事件發生，並處理事件；代碼像下面這樣：

[cpp]view plaincopy 
int res = select(maxfd+1, &readfds, NULL, NULL, 120);  
if (res > 0)  
{  
    for (int i = 0; i < MAX_CONNECTION; i++)  
    {  
        if (FD_ISSET(allConnection[i], &readfds))  
        {  
            handleEvent(allConnection[i]);  
        }  
    }  
}  
// if(res == 0) handle timeout, res < 0 handle error  

Epoll 不僅會告訴應用程序有I/0 事件到來，還會告訴應用程序相關的信息，這些信息是應用程序填充的，因此根據這些信息應用程序就能直接定位到事件，而不必遍歷整個FD 集合。

[cpp]view plaincopy 
int res = epoll_wait(epfd, events, 20, 120);  
for (int i = 0; i < res;i++)  
{  
    handleEvent(events[n]);  
}  

五）. Epoll 關鍵數據結構

前面提到 Epoll 速度快和其數據結構密不可分，其關鍵數據結構就是：

[cpp]view plaincopy 
struct epoll_event {  
    __uint32_t events;      // Epoll events  
    epoll_data_t data;      // User data variable  
};  
typedef union epoll_data {  
    void *ptr;  
    int fd;  
    __uint32_t u32;  
    __uint64_t u64;  
} epoll_data_t;  

可見 epoll_data 是一個 union 結構體 , 藉助於它應用程序可以保存很多類型的信息 :fd 、指針等等。有了它，應用程序就可以直接定位目標了。

六）. 使用 Epoll

既然 Epoll 相比 select 這麼好，那麼用起來如何呢？會不會很繁瑣啊 … 先看看下面的三個函數吧，就知道 Epoll 的易用了。

int epoll_create(int size);

生成一個 Epoll 專用的文件描述符，其實是申請一個內核空間，用來存放你想關注的 socket fd 上是否發生以及發生了什麼事件。 size 就是你在這個 Epoll fd 上能關注的最大 socket fd 數，大小自定，只要內存足夠。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event );

控制某個 Epoll 文件描述符上的事件：註冊、修改、刪除。其中參數 epfd 是 epoll_create() 創建 Epoll 專用的文件描述符。相對於 select 模型中的 FD_SET 和 FD_CLR 宏。

int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout);

等待 I/O 事件的發生；參數說明：

epfd: 由 epoll_create() 生成的 Epoll 專用的文件描述符；

epoll_event: 用於回傳代處理事件的數組；

maxevents: 每次能處理的事件數；

timeout: 等待 I/O 事件發生的超時值；

返回發生事件數。

相對於 select 模型中的 select 函數。

七）. 例子程序

下面是一個簡單 Echo Server 的例子程序，麻雀雖小，五臟俱全，還包含了一個簡單的超時檢查機制，簡潔起見沒有做錯誤處理。

[cpp]view plaincopy 
//   
// a simple echo server using epoll in linux  
//   
// 2009-11-05  
// 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;  
    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;  
    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]/n", ev->fd);  
    else  
        printf("Event Add OK[fd=%d]/n", ev->fd);  
}  
// 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: bad accept", __func__);  
        }  
        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  
        if(fcntl(nfd, F_SETFL, O_NONBLOCK) < 0) break;  
        // add a read event for receive data  
        EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);  
        EventAdd(g_epollFd, EPOLLIN|EPOLLET, &g_Events[i]);  
        printf("new conn[%s:%d][time:%d]/n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), g_Events[i].last_active);  
    }while(0);  
}  
// 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, sizeof(ev->buff)-1, 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|EPOLLET, ev);  
    }  
    else if(len == 0)  
    {  
        close(ev->fd);  
        printf("[fd=%d] closed gracefully./n", fd);  
    }  
    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->len, 0);  
    ev->len = 0;  
    EventDel(g_epollFd, ev);  
    if(len > 0)  
    {  
        // change to receive event  
        EventSet(ev, fd, RecvData, ev);  
        EventAdd(g_epollFd, EPOLLIN|EPOLLET, ev);  
    }  
    else  
    {  
        close(ev->fd);  
        printf("recv[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|EPOLLET, &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)  
{  
    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的優點：
1.支持一個進程打開大數目的socket描述符(FD)
select 最不能忍受的是一個進程所打開的FD是有一定限制的，由FD_SETSIZE設置，默認值是2048。對於那些需要支持的上萬連接數目的IM服務器來說顯然太少了。這時候你一是可以選擇修改這個宏然後重新編譯內核，不過資料也同時指出這樣會帶來網絡效率的下降，二是可以選擇多進程的解決方案(傳統的 Apache方案)，不過雖然linux上面創建進程的代價比較小，但仍舊是不可忽視的，加上進程間數據同步遠比不上線程間同步的高效，所以也不是一種完美的方案。不過 epoll則沒有這個限制，它所支持的FD上限是最大可以打開文件的數目，這個數字一般遠大於2048,舉個例子,在1GB內存的機器上大約是10萬左右，具體數目可以cat /proc/sys/fs/file-max察看,一般來說這個數目和系統內存關係很大。

2.IO效率不隨FD數目增加而線性下降
傳統的select/poll另一個致命弱點就是當你擁有一個很大的socket集合，不過由於網絡延時，任一時間只有部分的socket是"活躍"的，但是select/poll每次調用都會線性掃描全部的集合，導致效率呈現線性下降。但是epoll不存在這個問題，它只會對"活躍"的socket進行操作---這是因爲在內核實現中epoll是根據每個fd上面的callback函數實現的。那麼，只有"活躍"的socket纔會主動的去調用 callback函數，其他idle狀態socket則不會，在這點上，epoll實現了一個"僞"AIO，因爲這時候推動力在os內核。在一些 benchmark中，如果所有的socket基本上都是活躍的---比如一個高速LAN環境，epoll並不比select/poll有什麼效率，相反，如果過多使用epoll_ctl,效率相比還有稍微的下降。但是一旦使用idle connections模擬WAN環境,epoll的效率就遠在select/poll之上了。

3.使用mmap加速內核與用戶空間的消息傳遞。
這點實際上涉及到epoll的具體實現了。無論是select,poll還是epoll都需要內核把FD消息通知給用戶空間，如何避免不必要的內存拷貝就很重要，在這點上，epoll是通過內核於用戶空間mmap同一塊內存實現的。而如果你想我一樣從2.5內核就關注epoll的話，一定不會忘記手工 mmap這一步的。

4.內核微調
這一點其實不算epoll的優點了，而是整個linux平臺的優點。也許你可以懷疑linux平臺，但是你無法迴避linux平臺賦予你微調內核的能力。比如，內核TCP/IP協議棧使用內存池管理sk_buff結構，那麼可以在運行時期動態調整這個內存pool(skb_head_pool)的大小--- 通過echo XXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函數的第2個參數(TCP完成3次握手的數據包隊列長度)，也可以根據你平臺內存大小動態調整。更甚至在一個數據包面數目巨大但同時每個數據包本身大小卻很小的特殊系統上嘗試最新的NAPI網卡驅動架構。

########################################################

select/epoll的特點

select的特點：select 選擇句柄的時候，是遍歷所有句柄，也就是說句柄有事件響應時，select需要遍歷所有句柄才能獲取到哪些句柄有事件通知，因此效率是非常低。但是如果連接很少的情況下， select和epoll的LT觸發模式相比，性能上差別不大。
這裏要多說一句，select支持的句柄數是有限制的，同時只支持1024個，這個是句柄集合限制的，如果超過這個限制，很可能導致溢出，而且非常不容易發現問題， TAF就出現過這個問題，調試了n天，才發現：）當然可以通過修改linux的socket內核調整這個參數。
epoll的特點：epoll對於句柄事件的選擇不是遍歷的，是事件響應的，就是句柄上事件來就馬上選擇出來，不需要遍歷整個句柄鏈表，因此效率非常高，內核將句柄用紅黑樹保存的。相比於select，epoll最大的好處在於它不會隨着監聽fd數目的增長而降低效率。因爲在內核中的select實現中，它是採用輪詢來處理的，輪詢的fd數目越多，自然耗時越多。並且，在linux/posix_types.h頭文件有這樣的聲明：
#define __FD_SETSIZE 1024
表示select最多同時監聽1024個fd，當然，可以通過修改頭文件再重編譯內核來擴大這個數目，但這似乎並不治本。

對於epoll而言還有ET和LT的區別，LT表示水平觸發，ET表示邊緣觸發，兩者在性能以及代碼實現上差別也是非常大的。

epoll的LT和ET的區別

LT：水平觸發，效率會低於ET觸發，尤其在大併發，大流量的情況下。但是LT對代碼編寫要求比較低，不容易出現問題。LT模式服務編寫上的表現是：只要有數據沒有被獲取，內核就不斷通知你，因此不用擔心事件丟失的情況。
ET：邊緣觸發，效率非常高，在併發，大流量的情況下，會比LT少很多epoll的系統調用，因此效率高。但是對編程要求高，需要細緻的處理每個請求，否則容易發生丟失事件的情況。

epoll相關ＡＰＩ

epoll的接口非常簡單，一共就三個函數：

1. int epoll_create(int size);

創建一個epoll的句柄，size用來告訴內核這個監聽的數目一共有多大。這個參數不同於select()中的第一個參數，給出最大監聽的fd+1的值。需要注意的是，當創建好epoll句柄後，它就是會佔用一個fd值，在linux下如果查看/proc/進程id/fd/，是能夠看到這個fd的，所以在使用完epoll後，必須調用close()關閉，否則可能導致fd被耗盡。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

epoll的事件註冊函數，它不同與select()是在監聽事件時告訴內核要監聽什麼類型的事件，而是在這裏先註冊要監聽的事件類型。第一個參數是epoll_create()的返回值，第二個參數表示動作，用三個宏來表示：
EPOLL_CTL_ADD：註冊新的fd到epfd中；
EPOLL_CTL_MOD：修改已經註冊的fd的監聽事件；
EPOLL_CTL_DEL：從epfd中刪除一個fd；
第三個參數是需要監聽的fd，第四個參數是告訴內核需要監聽什麼事，struct epoll_event結構如下：

typedef union epoll_data {
void *ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;

struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

events可以是以下幾個宏的集合：
EPOLLIN ：表示對應的文件描述符可以讀（包括對端SOCKET正常關閉）；
EPOLLOUT：表示對應的文件描述符可以寫；
EPOLLPRI：表示對應的文件描述符有緊急的數據可讀（這裏應該表示有帶外數據到來）；
EPOLLERR：表示對應的文件描述符發生錯誤；
EPOLLHUP：表示對應的文件描述符被掛斷；
EPOLLET：將EPOLL設爲邊緣觸發(Edge Triggered)模式，這是相對於水平觸發(Level Triggered)來說的。
EPOLLONESHOT：只監聽一次事件，當監聽完這次事件之後，如果還需要繼續監聽這個socket的話，需要再次把這個socket加入到EPOLL隊列裏

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

等待事件的產生，類似於select()調用。參數events用來從內核得到事件的集合，maxevents告之內核這個events有多大，這個 maxevents的值不能大於創建epoll_create()時的size，參數timeout是超時時間（毫秒，0會立即返回，-1將不確定，也有說法說是永久阻塞）。該函數返回需要處理的事件數目，如返回0表示已超時。

示例代碼

epoll服務器

#include <sys/epoll.h>  
#include <netinet/in.h>  
#include <sys/types.h>          /* See NOTES */  
#include <sys/socket.h>  
#include <string.h>  
#include <stdio.h>  
#include <unistd.h>  
#include <fcntl.h>  
  
#include <errno.h>  
#include <stdlib.h>  
typedef struct sockaddr_in sockaddr_in ;  
typedef struct sockaddr     sockaddr ;  
  
#define SER_PORT    8080  
  
int nonblock(int fd){  
    int opt ;  
    opt = fcntl(fd,F_GETFL);  
    opt |= O_NONBLOCK ;  
    return fcntl(fd,F_SETFL,opt);  
}  
  
int main(int argc,char**argv){  
    sockaddr_in srv, cli ;  
    int listen_fd ,con_fd ;  
    socklen_t  len;  
    int res ,nsize,ws;  
    char buf[255];  
  
    int epfd,ers;  
    struct epoll_event evn,events[50];  
    int i;  
  
    bzero(&srv,sizeof(srv));  
    bzero(&cli,sizeof(cli));  
    srv.sin_port= SER_PORT ;  
    srv.sin_family = AF_INET ;  
    listen_fd = socket(AF_INET,SOCK_STREAM,0);  
  
    int yes = 1;  
    setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int));  
  
    if(bind(listen_fd,(sockaddr*)&srv,sizeof(sockaddr))<0)  {  
        perror("bind");  
        exit(0);  
    }  
    listen(listen_fd,100);  
    nonblock(listen_fd);  
    epfd = epoll_create(200);  
    evn.events = EPOLLIN|EPOLLET ;  
    evn.data.fd = listen_fd;   
    epoll_ctl(epfd,EPOLL_CTL_ADD,listen_fd,&evn);  
    static int count ;  
    while(1){  
        ers = epoll_wait(epfd,events,100,5000);  
        if(ers<0 ){  
            perror("epoll_wait:");exit(0);  
        }else if(ers==0){  
            printf("time out:%d\n",count++);  
            continue ;  
        }  
        for(i=0;i<ers;i++){  
            if(events[i].data.fd == listen_fd){  
                con_fd = accept(listen_fd,(sockaddr*)&cli ,&len);  
                nonblock(con_fd);  
                printf("connect from:%s\n",inet_ntoa(cli.sin_addr));  
                evn.data.fd = con_fd;  
                evn.events = EPOLLIN | EPOLLET ;  
                epoll_ctl(epfd,EPOLL_CTL_ADD,con_fd,&evn);  
  
            }else if(events[i].events & EPOLLIN){     
                  
                nsize = 0;  
                while((res=read(events[i].data.fd,buf+nsize,sizeof(buf)-1))>0){  
                    nsize+= res;  
                }  
                if(res==0){  
                    epoll_ctl(epfd,EPOLL_CTL_DEL,events[i].data.fd,NULL);     
                    printf("a client over\n");  
                    close(con_fd);  
                    continue ;  
                }else if(res<0 && errno!=EAGAIN){  
                    perror("read");  
                    continue ;  
                }  
                buf[nsize]=0;  
                evn.data.fd = events[i].data.fd;  
                evn.events=EPOLLOUT|EPOLLET ;  
                epoll_ctl(epfd,EPOLL_CTL_MOD,events[i].data.fd,&evn);                 
                  
            }else if(events[i].events & EPOLLOUT){  
                nsize = strlen(buf);  
                ws = 0;  
                while(nsize>0){  
                     ws=write(events[i].data.fd,buf,nsize);  
                    nsize-=ws;  
                }  
                evn.data.fd = events[i].data.fd;  
                evn.events=EPOLLIN|EPOLLET ;  
                epoll_ctl(epfd,EPOLL_CTL_MOD,events[i].data.fd,&evn);     
            }else{  
                printf("others\n");  
                  
            }             
        }  
  
    }  
  
    close(listen_fd);  
      
    return 0;  
}  

客戶端測試代碼：

#include <sys/epoll.h>
#include <netinet/in.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <strings.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
typedef struct sockaddr_in sockaddr_in ;
typedef struct sockaddr sockaddr ;
#define SER_PORT 8080
#define IP_ADDR "10.33.28.230"
int main(int argc,char**argv){
sockaddr_in srv, cli ;
int listen_fd ,con_fd ;
socklen_t len;
int res,ws ;
char buf[255];
bzero(&srv,sizeof(srv));
bzero(&cli,sizeof(cli));
srv.sin_port= SER_PORT ;
srv.sin_family = AF_INET ;
inet_pton(AF_INET,IP_ADDR,&srv.sin_addr);
listen_fd = socket(AF_INET,SOCK_STREAM,0);
if(connect(listen_fd,(sockaddr*)&srv,sizeof(sockaddr))<0){
perror("connect");
exit(0);
}
while(1){
res = read(STDIN_FILENO,buf,sizeof(buf)-1);
ws = write(listen_fd,buf,res);
res = read(listen_fd,buf,sizeof(buf)-1);
ws = write(STDOUT_FILENO,buf,res);
}
close(listen_fd);
return 0;
}

Linux下select, poll和epoll IO模型的詳解

select/epoll的特點

epoll的LT和ET的區別

epoll相關ＡＰＩ

1. int epoll_create(int size);

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

示例代碼

epoll服務器

客戶端測試代碼：

高效率使用windows

【OpenCV學習筆記】2.3 OpenCV2.2攝像頭讀取視頻的問題和解決（VS2010）

C# 4.0 並行計算部分 [轉發]

新中新二代身份證dll調用，報嘗試讀取或寫入受保護的內存,這通常指示其他內存已損壞這個錯 ...

C#如何以管理員身份運行程序

IIS故障問題(Connections_Refused)分析及處理

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結