I/O多路转接之select
系统提供select函数来实现多路复用输入/输出模型。select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有一个或多个发生了状态改变。关于文件句柄，其实就是一个整数，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr。
参数nfds是需要监视的最大的文件描述符值+1；
rdset,wrset,exset，timeou既为输入型参数，又为输出型参数。
rdset,wrset,exset做为输入时分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集合及异常文件描述符的集合。
作为输出型参数时，则表示需要检测的可读文件描述符的集合，可写文件描述符的集合及异常文件描述符的集合中有哪些文件已经就绪。
struct timeval结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为0。
下面的宏提供了处理这三种描述词组的方式:
FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位
FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真
FD_SET（int fd,fd_set*set）；用来设置描述词组set中相关fd的位
FD_ZERO（fd_set *set）；用来清除描述词组set的全部位参数timeout为结构timeval，
用来设置select()的等待时间，其结构定义如下：
如果参数timeout设为：
NULL：则表示select（）没有timeout，select将一直被阻塞，直到某个文件描述符上发生了事件。
0：仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生。特定的时间值：如果在指定的时间段没有事件发生，select将超时返回。
函数返回值：
执行成功则返回文件描述词状态已改变的个数
如果返回0代表在描述词状态改变前已超过timeout时间，没有返回；
当有错误发生时则返回-1，错误原因存于errno，此时参数readfds，writefds，exceptfds和timeout的值变成不可预测。错误值可能为：
EBADF 文件描述词为无效的或该文件已关闭EINTR 此调用被信号所中断
EINVAL 参数n为负值。
ENOMEM 核心内存不足
常见的程序片段如下：
fs_set readset；
FD_SET(fd,&readset);
select(fd+1,&readset,NULL,NULL,NULL);
if(FD_ISSET(fd,readset))
{……}
理解select模型：
理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节，fd_set中的每个bit可以对应一个文件描述符fd。则1字节长的fd_set最多可以对应8个fd。
（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。
（2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)
（3）若再加上fd＝2，fd=1,则set变为0001,0011
（4）执行select(6,&set,0,0,0)阻塞等待
（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。
基于上面的讨论，可以轻松得出select模型的特点：
（1)可监控的文件描述符个数取决与sizeof(fd_set)的值。我这边服务器上sizeof(fd_set)＝512，每bit表示一个文件描述符，则我服务器上支持的最大的件描述符是512*8=4096。据说可调，另有说虽然可调，但调整上限受于编译内核时的变量值。本文对调整fd_set的大小不太感兴趣，参考http://www.cppblog.com /CppExplore/archive/2008/03/21/45061.html中的模型2（1）可以有效突破select可监控的文件描述符上限。
（2）将fd加入select监控集的同时，还要再使用一个数据结构array保存放到select监控集中的fd，一是用于在select返回后，array作为源数据和fd_set进行FD_ISSET判断。二是select返回后会把以前加入的但并无事件发生的fd清空，则每次开始select前都要重新从array取得fd逐一加入（FD_ZERO最先），扫描array的同时取得fd最大值maxfd，用于select的第一个参数。
（3）可见select模型必须在select前循环array（加fd，取maxfd），select返回后循环array（FD_ISSET判断是否有时间发生）
select实现简单的TCP服务器
server.c
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h>
#define _MAX_SIZE_ 128
void Usge(const char* proc)
{
printf("Usge %s [IP] [PORT] \n",proc);
}
//create socket
int startUp(char* _ip,char* _port)
{
int sock =socket(AF_INET,SOCK_STREAM,0);
if(sock < 0)
{
perror("socket");
exit(1);
}
struct sockaddr_in local;
local.sin_family = AF_INET;
local.sin_port = htons(atoi(_port));
local.sin_addr.s_addr = inet_addr(_ip);
int opt =1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
{
perror("bind");
exit(2);
}
if(listen(sock,5) < 0)
{
perror("listen");
exit(3);
}
return sock;
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
Usge(argv[0]);
}
int listen_sock = startUp(argv[1],argv[2]);
int fds[_MAX_SIZE_];
int nSock = 0;
for(; nSock< _MAX_SIZE_; nSock++)
{
fds[nSock] = -1;
}
fds[0] = listen_sock;
int max_fd = listen_sock;
fd_set rfds;
int done = 0;
while(!done)
{
FD_ZERO(&rfds);
int i = 0;
for(; i< _MAX_SIZE_; i++)
{
if(fds[i] != -1)
{
FD_SET(fds[i],&rfds);
max_fd = max_fd > fds[i] ? max_fd:fds[i];
}
}
struct timeval timeout = {5,0};
switch(select(max_fd+1,&rfds,NULL,NULL,NULL))
{
case 0:
printf("time out\n");
break;
case -1:
perror("select");
break;
default:
{
int index = 0;
for(; index < _MAX_SIZE_; index++)
{
if(index == 0 && fds[index] == listen_sock && FD_ISSET(listen_sock,&rfds))
{
//accept
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int new_fd = accept(listen_sock,(struct sockaddr *)&peer,&len);
if(new_fd < 0)
{
perror("accept");
return 1;
}
else
{
printf("get a new client :ip : %s port :%d \n",inet_ntoa(peer.sin_addr),ntohs(peer.sin_port));
int i =0;
for(i =0; i < _MAX_SIZE_; i++)
{
if(fds[i]==-1)
{
fds[i] = new_fd;
break;
}
}
if(i == _MAX_SIZE_)
{
printf("fds is full close new_fd...\n");
close(new_fd);
}
}
}
else if(fds[index] != -1 && FD_ISSET(fds[index],&rfds))
{
char buf[1024];
ssize_t _s = read(fds[index],buf,sizeof(buf));
if(_s > 0)
{
buf[_s] = '\0';
printf("client fd :%d #:%s",fds[index],buf);
}
else if( _s == 0)
{
printf("client is closed...\n");
FD_CLR(fds[index],&rfds);
close(fds[index]);
fds[index] = -1;
}
else
{
perror("read");
}
}
}
}
break;
}
}
return 0;
} 运行效果图
server端
client端
I/O多路转接之poll
不同与select使用三个位图来表示三个fdset的方式，poll使用一个 pollfd的指针实现。
pollfd结构包含了要监视的event和发生的event，不再使用select“参数-值”传递的方式。同时，pollfd并没有最大数量限制（但是数量过多后性能也是会下降）。和select函数一样，poll返回后，需要轮询pollfd来获取就绪的描述符。
从上面看，select和poll都需要在返回后，通过遍历文件描述符来获取已经就绪的socket。事实上，同时连接的大量客户端在同一时刻可能只有很少的处于就绪状态，因此随着监视的描述符数量的增长，其效率也会线性下降。
由于它和select在本质上没有多大差别，只是poll没有最大文件描述符数量的限制。所以搭建poll服务器参见select写法，接下来只给出一个使用poll监控输入输出的样例。
#include <stdio.h>
#include <poll.h>
int main()
{
struct pollfd poll_set[1];
poll_set[0].fd = 0;
poll_set[0].events = POLLIN;
poll_set[0].revents = 0;
int timeout = 1000;<img src="file:///C:\Users\LeetCode\AppData\LocalLow\Baidu\BAIDUP~1\Account\COMMON~1\CUSTOM~1\RECOMM~1\08CB1B~1.GIF" alt="" /> int max_fd = 0;
while(1)
{
switch(poll(poll_set,max_fd+1,timeout))<span style="white-space:pre"> </span>{
case 0:
printf("time out\n");
break;
case -1:
printf("poll");
break;
default:
{
char buf[1024];
ssize_t _s = read(0,buf,sizeof(buf));
if(_s > 0)
{
buf[_s] = '\0';
printf("echo #%s",buf);
}
}
break;<span style="white-space:pre"> </span>}
}
return 0;
} 
I/O多路转接之epoll
什么是epoll
epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。
epoll的相关系统调用
epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用。
1. int epoll_create(int size);
创建一个epoll的句柄。自从linux2.6.8之后，size参数是被忽略的。需要注意的是，当创建好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结构如下
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);
收集在epoll监控的事件中已经发送的事件。参数events是分配好的epoll_event结构体数组，epoll将会把发生的事件赋值到events数组中（events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在用户态中分配内存）。maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。如果函数调用成功，返回对应I/O上已准备好的文件描述符数目，如返回0表示已超时。
Epoll的2种工作方式-水平触发（LT）和边缘触发（ET）
假如有这样一个例子：
1. 我们已经把一个用来从管道中读取数据的文件句柄(RFD)添加到epoll描述符
2. 这个时候从管道的另一端被写入了2KB的数据
3. 调用epoll_wait(2)，并且它会返回RFD，说明它已经准备好读取操作
4. 然后我们读取了1KB的数据
5. 调用epoll_wait(2)......
Edge Triggered 工作模式：
如果我们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志，那么在第5步调用epoll_wait(2)之后将有可能会挂起，因为剩余的数据还存在于文件的输入缓冲区内，而且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件。因此在第5步的时候，调用者可能会放弃等待仍在存在于文件输入缓冲区内的剩余数据。在上面的例子中，会有一个事件产生在RFD句柄上，因为在第2步执行了一个写操作，然后，事件将会在第3步被销毁。因为第4步的读取操作没有读空文件输入缓冲区内的数据，因此我们在第5步调用 epoll_wait(2)完成后，是否挂起是不确定的。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。最好以下面的方式调用ET模式的epoll接口，在后面会介绍避免可能的缺陷。
i 基于非阻塞文件句柄
ii 只有当read(2)或者write(2)返回EAGAIN时才需要挂起，等待。但这并不是说每次read()时都需要循环读，直到读到产生一个EAGAIN才认为此次事件处理完成，当read()返回的读到的数据长度小于请求的数据长度时，就可以确定此时缓冲中已没有数据了，也就可以认为此事读事件已处理完成。
Level Triggered 工作模式
相反的，以LT方式调用epoll接口的时候，它就相当于一个速度比较快的poll(2)，并且无论后面的数据是否被使用，因此他们具有同样的职能。因为即使使用ET模式的epoll，在收到多个chunk的数据的时候仍然会产生多个事件。调用者可以设定EPOLLONESHOT标志，在 epoll_wait(2)收到事件后epoll会与事件关联的文件句柄从epoll描述符中禁止掉。因此当EPOLLONESHOT设定后，使用带有 EPOLL_CTL_MOD标志的epoll_ctl(2)处理文件句柄就成为调用者必须作的事情。
LT(level triggered)是epoll缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你 的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表．
ET (edge-triggered)是高速工作方式，只支持no-block socket，它效率要比LT更高。ET与LT的区别在于，当一个新的事件到来时，ET模式下当然可以从epoll_wait调用中获取到这个事件，可是如果这次没有把这个事件对应的套接字缓冲区处理完，在这个套接字中没有新的事件再次到来时，在ET模式下是无法再次从epoll_wait调用中获取这个事件的。而LT模式正好相反，只要一个事件对应的套接字缓冲区还有数据，就总能从epoll_wait中获取这个事件。
因此，LT模式下开发基于epoll的应用要简单些，不太容易出错。而在ET模式下事件发生时，如果没有彻底地将缓冲区数据处理完，则会导致缓冲区中的用户请求得不到响应。
epoll默认为LT模式
注意：
epoll ET模式fd必须要设置为非阻塞
ET（边缘触发）数据就绪只会通知一次，也就是说，如果要使用ET模式，当数据就绪时，需要一直read，直到出错或完成为止。但倘若当前fd为阻塞（默认），那么在当读完缓冲区的数据时，如果对端并没有关闭写端，那么该read函数会一直阻塞，影响其他fd以及后续逻辑！所以此时将该fd设置为非阻塞，当没有数据的时候，read虽然读取不到任何内容，但是肯定不会被hang住，那么此时，说明缓冲区数据已经读取完毕，需要继续处理后续逻辑（读取其他fd或者进如wait）。
//设置文件描述符为非阻塞
void set_noblock(int fd)
{
int fl = fcntl(fd,F_GETFL);
if(fl < 0)
{
perror("fcntl error!\n");
return;
}
if(fcntl(fd,F_SETFL,fl|O_NONBLOCK))
{
perror("fcntl set nonblock error\n");
return;
}
}
epoll实现的网络服务器（采用的是默认的LT模式）
server.c
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#define _MAX_SIZE_ 128
void Usge(const char* proc)
{
printf("Usge %s [IP] [PORT] \n",proc);
}
//create socket
int startUp(char* _ip,char* _port)
{
int sock =socket(AF_INET,SOCK_STREAM,0);
if(sock < 0)
{
perror("socket");
exit(1);
}
struct sockaddr_in local;
local.sin_family = AF_INET;
local.sin_port = htons(atoi(_port));
local.sin_addr.s_addr = inet_addr(_ip);
int opt =1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
{
perror("bind");
exit(2);
}
if(listen(sock,5) < 0)
{
perror("listen");
exit(3);
}
return sock;
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
Usge(argv[0]);
}
int listen_sock = startUp(argv[1],argv[2]);
int epfd = epoll_create(256);
if(epfd < 0)
{
perror("epoll_create");
close(listen_sock);
return 1;
}
struct epoll_event ev,revs[128];
int size = sizeof(revs)/sizeof(revs[0]);
int j = 0;
for(; j<size; j++)
{
revs[j].events = 0;
revs[j].data.fd = -1;
}
ev.data.fd = listen_sock;
ev.events = EPOLLIN;
if(epoll_ctl(epfd,EPOLL_CTL_ADD,listen_sock,&ev) < 0)
{
perror("epoll_ctl");
close(listen_sock);
close(epfd);
return 2;
}
int timeout = -1;
int done = 0;
while(!done)
{
int num = epoll_wait(epfd,revs,_MAX_SIZE_,timeout);
switch(num)
{
case 0:
printf("timeout...\n");
break;
case -1:
perror("epoll_wait");
close(listen_sock);
close(epfd);
return 3;
break;
default:
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int i =0;
for(; i<num; i++)
{
int rsock = revs[i].data.fd;
//accept
if(revs[i].events & EPOLLIN && (rsock == listen_sock))
{
int new_fd = accept(listen_sock,(struct sockaddr*)&peer,&len);
if(new_fd < 0)
{
perror("accept");
return 4;
}
printf("get a new client IP :%s PORT : %d\n",inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));
ev.events = EPOLLIN;
ev.data.fd = new_fd;
epoll_ctl(epfd,EPOLL_CTL_ADD,new_fd,&ev);
}
//read
else if(revs[i].events & EPOLLIN)
{
char buf[1024];
ssize_t _s = read(rsock,buf,sizeof(buf));
if(_s > 0)
{
buf[_s] = '\0';
printf("client # %s",buf);
ev.events = EPOLLOUT;//modify write
epoll_ctl(epfd,EPOLL_CTL_MOD,rsock,&ev);
}
else if (_s == 0)
{
printf("client is closed...\n");
epoll_ctl(epfd,EPOLL_CTL_DEL,rsock,NULL);
close(rsock);
}
}
//write
else if(revs[i].events & EPOLLOUT)
{
const char* msg = "HTTP/1.1 200 OK\r\n\r\n<html><h1>hello world ++_++||</h1></html>\r\n";
write(rsock,msg,strlen(msg));
//ev.events = EPOLLIN;
//epoll_ctl(epfd,EPOLL_CTL_MOD,rsock,&ev);
epoll_ctl(epfd,EPOLL_CTL_DEL,rsock,NULL);
close(rsock);
}
}
}
break;
}
}
return 0;
} 效果图：
select、poll、epoll总结
select的几大缺点：
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
（3）select支持的文件描述符数量太小了，默认是1024
poll的实现和select非常相似，只是描述fd集合的方式不同，poll使用pollfd结构而不是select的fd_set结构，其他的都差不多。
关于select和poll的实现分析，可以参考下面几篇博文：
http://blog.csdn.net/lizhiguo0532/article/details/6568964#comments
http://blog.csdn.net/lizhiguo0532/article/details/6568968
http://blog.csdn.net/lizhiguo0532/article/details/6568969
http://www.ibm.com/developerworks/cn/linux/l-cn-edntwk/index.html?ca=drs-
http://linux.chinaunix.net/techdoc/net/2009/05/03/1109887.shtml
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网卡驱动架构。
epoll高效的奥秘
epoll精巧的使用了3个方法来实现select方法要做的事：
1）新建epoll描述符==epoll_create()
2）epoll_ctrl(epoll描述符，添加或者删除所有待监控的连接)
3)返回的活跃连接 ==epoll_wait（epoll描述符 ）
要深刻理解epoll，首先得了解epoll的三大关键要素：mmap、红黑树、链表。
epoll是通过内核与用户空间mmap同一块内存实现的。mmap将用户空间的一块地址和内核空间的一块地址同时映射到相同的一块物理内存地址（不管是用户空间还是内核空间都是虚拟地址，最终要通过地址映射映射到物理地址），使得这块物理内存对内核和对用户均可见，减少用户态和内核态之间的数据交换。内核可以直接看到epoll监听的句柄，效率高。
红黑树将存储epoll所监听的套接字。上面mmap出来的内存如何保存epoll所监听的套接字，必然也得有一套数据结构，epoll在实现上采用红黑树去存储所有套接字，当添加或者删除一个套接字时（epoll_ctl），都在红黑树上去处理，红黑树本身插入和删除性能比较好，时间复杂度O(logN)。
添加以及返回事件
通过epoll_ctl函数添加进来的事件都会被放在红黑树的某个节点内，所以，重复添加是没有用的。当把事件添加进来的时候时候会完成关键的一步，那就是该事件都会与相应的设备（网卡）驱动程序建立回调关系，当相应的事件发生后，就会调用这个回调函数，该回调函数在内核中被称为：ep_poll_callback,这个回调函数其实就所把这个事件添加到rdllist这个双向链表中。一旦有事件发生，epoll就会将该事件添加到双向链表中。那么当我们调用epoll_wait时，epoll_wait只需要检查rdlist双向链表中是否有存在注册的事件，效率非常可观。这里也需要将发生了的事件复制到用户态内存中即可。
epoll_wait的工作流程：
- epoll_wait调用ep_poll，当rdlist为空（无就绪fd）时挂起当前进程，直到rdlist不空时进程才被唤醒。
- 文件fd状态改变（buffer由不可读变为可读或由不可写变为可写），导致相应fd上的回调函数ep_poll_callback()被调用。
- ep_poll_callback将相应fd对应epitem加入rdlist，导致rdlist不空，进程被唤醒，epoll_wait得以继续执行。
- ep_events_transfer函数将rdlist中的epitem拷贝到txlist中，并将rdlist清空。
- ep_send_events函数（很关键），它扫描txlist中的每个epitem，调用其关联fd对用的poll方法。此时对poll的调用仅仅是取得fd上较新的events（防止之前events被更新），之后将取得的events和相应的fd发送到用户空间（封装在struct epoll_event，从epoll_wait返回）。
小结
表 1. select、poll和epoll三种I/O复用模式的比较（ 摘录自《linux高性能服务器编程》）
| 系统调用 | select | poll | epoll |
|
事件集合 | 用哦过户通过3个参数分别传入感兴趣的可读，可写及异常等事件 内核通过对这些参数的在线修改来反馈其中的就绪事件 这使得用户每次调用select都要重置这3个参数 | 统一处理所有事件类型，因此只需要一个事件集参数。 用户通过pollfd.events传入感兴趣的事件，内核通过 修改pollfd.revents反馈其中就绪的事件 | 内核通过一个事件表直接管理用户感兴趣的所有事件。 因此每次调用epoll_wait时，无需反复传入用户感兴趣 的事件。epoll_wait系统调用的参数events仅用来反馈就绪的事件 |
| 应用程序索引就绪文件 描述符的时间复杂度 | O(n) | O(n) | O(1) |
| 最大支持文件描述符数 | 一般有最大值限制 | 65535 | 65535 |
| 工作模式 | LT | LT | 支持ET高效模式 |
| 内核实现和工作效率 | 采用轮询方式检测就绪事件，时间复杂度：O(n) | 采用轮询方式检测就绪事件，时间复杂度：O(n) | 采用回调方式检测就绪事件，时间复杂度：O(1) |
需要注意的是：epoll并不是在所有的应用场景都会比select和poll高很多。尤其是当活动连接比较多的时候，回调函数被触发得过于频繁的时候，epoll的效率也会受到显著影响！所以，epoll特别适用于连接数量多，但活动连接较少的情况。
参考博客：http://www.cnblogs.com/lojunren/p/3856290.html
扫一扫
431
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
