按照man手册的说法：是为处理大批量句柄而作了改进的poll。它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。
int epoll_create(int size);
创建一个epoll的句柄。自从linux2.6.8之后，size参数是被忽略的。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
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队列里
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同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。
假如有这样一个例子：
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模式下事件发生时，如果没有彻底地将缓冲区数据处理完，则会导致缓冲区中的用户请求得不到响应。
1.支持一个进程打开大数目的socket描述符(FD)
select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显然太少了。不过 epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048。
2.IO效率不随FD数目增加而线性下降
传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃"的，但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会。
3.使用mmap加速内核与用户空间的消息传递
这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。
4.内核微调
（不太懂！）
服务器端：
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <string.h>
#define _MAX_LISTEN_ 5
#define _MAX_SIZE_ 10
#define _BUF_SIZE_ 1024
void Usage(const char* proc)
{
printf("%s usage: [ip] [port]\n", proc);
}
int startup(const char* _ip, const char* _port)
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
perror("socket");
exit(1);
}
int opt = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
{
perror("setsockopt");
exit(2);
}
struct sockaddr_in local;
local.sin_family = AF_INET;
local.sin_port = htons(atoi(_port));
local.sin_addr.s_addr = inet_addr(_ip);
if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
{
perror("bind");
exit(3);
}
if(listen(sock, _MAX_LISTEN_) < 0)
{
perror("listen");
exit(4);
}
return sock;
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
Usage(argv[0]);
return 1;
}
int listen_sock = startup(argv[1], argv[2]);
int epoll_fd = epoll_create(128);
if(epoll_fd < 0)
{
perror("epoll_create");
close(listen_sock);
exit(5);
}
struct epoll_event ev, revent[_MAX_SIZE_];
ev.data.fd = listen_sock;
ev.events = EPOLLIN;
if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock, &ev) < 0)
{
perror("epoll_ctl add error");
exit(6);
}
int timeout = -1;
while(1)
{
int revent_len = sizeof(revent)/sizeof(revent[0]);
int epoll_n = epoll_wait(epoll_fd, revent, revent_len, timeout);
switch(epoll_n)
{
case -1:
perror("epoll_wait");
exit(7);
break;
case 0:
printf("time out\n");
break;
default:
{
int index = 0;
int new_fd = -1;
for(; index < epoll_n; ++index)
{
new_fd = revent[index].data.fd;
if(new_fd == listen_sock) //new accpet
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
new_fd = accept(listen_sock, (struct sockaddr* )&peer, &len);
if(new_fd < 0)
{
perror("accept");
exit(8);
}
printf("get a new client %d -> ip: %s port: %d\n", new_fd, inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));
ev.data.fd = new_fd;
ev.events = EPOLLIN;
if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, new_fd, &ev) < 0)
{
perror("epoll_ctl add error");
close(new_fd);
exit(9);
}
continue;
}
if(revent[index].events & EPOLLIN) //new read
{
char buf[_BUF_SIZE_];
int _s = read(new_fd, buf, sizeof(buf)-1);
if(_s > 0)
{
buf[_s] = ‘\0‘;
printf("client %d # %s\n",new_fd, buf);
}
else if(_s == 0)
{
printf("client %d is closed\n", new_fd);
close(new_fd);
epoll_ctl(epoll_fd, EPOLL_CTL_DEL, new_fd, NULL);
}
else
{
perror("read");
}
}
ev.data.fd = new_fd;
ev.events = EPOLLOUT;
if(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, new_fd, &ev) < 0)
{
perror("epoll_ctl mod error");
close(new_fd);
exit(10);
}
if(revent[index].events & EPOLLOUT)
{
const char* msg = "Hello World ^_^";
write(new_fd, msg, strlen(msg));
close(new_fd);
epoll_ctl(epoll_fd, EPOLL_CTL_DEL, new_fd, NULL);
}
}
}
}
}
return 0;
}客户端：
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
void Usage(const char* proc)
{
printf("usage: %s [ip] [port]\n", proc);
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
Usage(argv[0]);
exit(1);
}
int conn_sock = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in conn;
conn.sin_family = AF_INET;
conn.sin_port = htons(atoi(argv[2]));
conn.sin_addr.s_addr = inet_addr(argv[1]);
if(connect(conn_sock, (const struct sockaddr*)&conn, sizeof(conn)) < 0)
{
perror("connect");
exit(2);
}
char buf[1024];
memset(buf, ‘\0‘, sizeof(buf));
while(1)
{
printf("please enter # ");
fflush(stdout);
ssize_t _s = read(0, buf, sizeof(buf)-1);
if(_s > 0)
{
buf[_s-1] = ‘\0‘;
write(conn_sock, buf, strlen(buf));
}
_s = read(conn_sock, buf, sizeof(buf)-1);
if(_s > 0)
{
buf[_s] = ‘\0‘;
printf("sever # %s\n", buf);
}
}
return 0;
}程序演示：
浏览器
客户端
select/poll/epoll优缺点分析
select
select本质是通过设置或检查存放fd标志位的数据结构来进行下一步的处理。会阻塞，直到有一个或多个I/O就绪。
监视的文件描述符分为三类set，每一种对应不同的事件。readfds、writefds和exceptfds是指向描述符集的指针。
readfds列出的文件描述符被监视是否有数据可供读取。（可读）
writefds列出的文件描述符被监视是否有写入操作完成。（可写）
exceptfds列出的文件描述符被监视是否发生异常，或无法控制的数据是否可用。（仅仅用于socket）
这三类set为NULL时，select()不监视其对应的该类事件。
select()成功返回时，每组set都被修改以使它只包含准备好的I/O描述符。
特点：
(a)单个进程可监视的fd数量被限制；
(b)需要维护一个用来存放大量fd的数据结构，这样会使用户空间和内核空间在传递该结构时复制开销大；
(c)对fd进行扫描是线性的，fd剧增后，IO效率较低，因为每次调用都对fd进行线性扫描遍历，所以随着fd的增加会造成遍历速度慢的性能问题；
(d)内核需要将消息传递用户空间，需要内核拷贝动作；
(e)最大支持1024个fd。
poll
和select基本一样，除了poll没有使用低效的三个基于位的文件描述符set，而是采用了一个单独的结构体pollfd数组，由fds指针指向这个组。
特点：
(a)它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态，如果设备就绪则在设备等待队列中加入一项并继续遍历。如果遍历完所有fd后没有发现就绪设备，则挂起当前进程，直到设备就绪或主动超时，被唤醒后它又要再次遍历fd；
(b)没有最大连接数的限制，原因是它是基于链表来存储的；
(c)大量的fd的数组被整体复制于用户态和内核地址空间；
(d)对fd的扫描是线性的；
(e)水平触发：如果报告了fd后，没有被处理，那么下次poll时会再次报告该fd。
epoll
介绍如上
特点：
(a)支持一个进程打开最大数目的socket描述符(FD)。所支持的FD上限是最大可以打开文件的数组，在1GB机器上，大约为10万左右；
(b)IO效率不随fd数目增加而线性下降；（select/poll每次调用都会线性扫描全部的集合；epoll中只有活跃的socket才会主动调用callback函数，其他idle状态的socket则不会）
(c)使用mmap减少复制开销，加速内核与用户空间的消息传递；（epoll是通过内核和用户空间共享同一块内存实现的）
(d)支持边缘触发，只告诉进程中哪些fd刚刚变为就绪态，并且只通知一次。（epoll使用事件的就绪通知方式，通过epoll_ctl函数注册fd。一旦该fd就绪，内核就会采用类似callback的回调机制激活该fd，epoll_wait便可以收到通知。）
本文出自 “11408774” 博客，请务必保留此出处http://11418774.blog.51cto.com/11408774/1836638
原文地址：http://11418774.blog.51cto.com/11408774/1836638
