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

pmkyqwxdey

一）.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, &readfds))  
  
•         {  
  
•             handleEvent(allConnection);  
  
•         }  
  
•     }  
  
• }  
  
• // 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.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, nfd, RecvData, &g_Events);  
  
•         EventAdd(g_epollFd, EPOLLIN|EPOLLET, &g_Events);  
  
•         printf("new conn[%s:%d][time:%d]/n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), g_Events.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.data.ptr;  
  
•             if((events.events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event  
  
•             {  
  
•                 ev->call_back(ev->fd, events.events, ev->arg);  
  
•             }  
  
•             if((events.events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event  
  
•             {  
  
•                 ev->call_back(ev->fd, events.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.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.events & EPOLLIN){     
  
•                   
  
•                 nsize = 0;  
  
•                 while((res=read(events.data.fd,buf+nsize,sizeof(buf)-1))>0){  
  
•                     nsize+= res;  
  
•                 }  
  
•                 if(res==0){  
  
•                     epoll_ctl(epfd,EPOLL_CTL_DEL,events.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.data.fd;  
  
•                 evn.events=EPOLLOUT|EPOLLET ;  
  
•                 epoll_ctl(epfd,EPOLL_CTL_MOD,events.data.fd,&evn);                 
  
•                   
  
•             }else if(events.events & EPOLLOUT){  
  
•                 nsize = strlen(buf);  
  
•                 ws = 0;  
  
•                 while(nsize>0){  
  
•                      ws=write(events.data.fd,buf,nsize);  
  
•                     nsize-=ws;  
  
•                 }  
  
•                 evn.data.fd = events.data.fd;  
  
•                 evn.events=EPOLLIN|EPOLLET ;  
  
•                 epoll_ctl(epfd,EPOLL_CTL_MOD,events.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;  
  
• }