问题聚焦：
前篇提到了I/O处理单元的四种I/O模型。
本篇详细介绍实现这些I/O模型所用到的相关技术。
核心思想：I/O复用
使用情景：
- 客户端程序要同时处理多个socket。
- 客户端程序要同时处理用户输入和网络连接。
- TCP服务器要同时处理监听socket和连接socket，这是使用最多的场合。
- 服务器要同时处理TCP请求和UDP请求。
- 服务器要同时监听多个端口或者处理多种服务。
主要技术：
select系统调用
作用：
在一段指定时间内，监听用户感兴趣的文件描述符的可读、可写和异常等事件。
select API
原型：
1. #include <sys/select.h>
2. int select ( int nfds, fd_set* readfds, fde_set* writefds, fd_set* exceptfds, struct timeval* timeout );
函数说明：
- nfds： 指定被监听的文件描述符的总数，通常为所有文件描述符中的最大值+1
- readfds、writefds 、exceptfds： 可读、可写和异常等事件对应的文件描述符集合。
- fd_set结构：仅包含一个整型数组，该数组的每个元素的每一位标记了一个文件描述符。fd_set能容纳的文件描述符数量由FD_SETSIZE指定，这就限制了select能同时处理的文件描述符的总量。
select中的fd_set集合容量的限制为FD_SETSIZE，一般为1024 。修改它，需要重新编译内核。
fd_set相关的位操作：
1. #include <sys/select.h>
2. FD_ZERO( fd_set *fdset );
3. FD_SET( int fd, fd_set *fdset );
4. FD_CLR( int fd, fd_set *fdset );
5. int FD_ISSET( int fd, fd_set *fdset );
- timeout：设置select的超时时间。这是timeval结构指针，用来告诉内核select等待多久。不过我们不能完全信任select调用返回后的timeout值，比如调用失败时，timeout值是不确定的。timeval结构体如下：
1. struct timeval
2. {
3. long tv_sec; \\秒数
4. long tv_usec; \\微秒
5. }
如果给timeout变量的tv_sec成员和tv_usec成员都传递0，则select将立即返回。如果给timeout传递NULL，则select将一直阻塞，直到某个文件描述符就绪。
返回状态：
- select成功时返回就绪（可读、可写和异常）文件描述符的总数。
- 如果在超时时间内没有任何文件描述符就绪，select将返回0。
- select失败时返回-1并设置errno。
- 如果select 等待期间，程序接收到信号，则select立即返回-1，并设置errno为EINTR。
文件描述符就绪条件
可读：
- socket内核接收缓冲区中的字节数大于或等于其低水位标记SO_RCVLOWAT。此时我们可以无阻塞地对该socket，并且读操作返回的字节数大于0。
- socket通信的对方关闭连接，此时读操作返回0。
- 监听socket上有新的连接请求。
- socekt上有未处理的错误，此时我们可以使用getsockopt来读取和清除该错误。
可写：
- socket内核发送缓冲区中的可用字节数大于或等于其低水位标记SO_SNDLOWAT。此时我们可以无阻塞地写该socket，并且写操作返回的字节数大于0。
- socket的写操作被关闭。对写操作被关闭的socket执行写操作将出发一个SIGPIPE信号。
- socket使用非阻塞connect连接成功或者失败之后。
- socket上有未处理的错误，此时我们可以使用getsockopt来读取和清除该错误。
异常：
处理带外数据
socket上接收到普通数据和带外数据都将使select返回，但socket处于不同的就绪状态：前者处于可读状态，后者处于异常状态。
1. #include <sys/types.h>
2. #include <sys/socket.h>
3. #include <netinet/in.h>
4. #include <arpa/inet.h>
5. #include <assert.h>
6. #include <stdio.h>
7. #include <unistd.h>
8. #include <errno.h>
9. #include <string.h>
10. #include <fcntl.h>
11. #include <stdlib.h>
12.
13. int main( int argc, char* argv[] )
14. {
15. if( argc <= 2 )
16. {
17. "usage: %s ip_address port_number\n", basename( argv[0] ) );
18. return 1;
19. }
20. const char* ip = argv[1];
21. int port = atoi( argv[2] );
22. "ip is %s and port is %d\n", ip, port );
23.
24. int ret = 0;
25. struct sockaddr_in address;
26. sizeof( address ) );
27. address.sin_family = AF_INET;
28. inet_pton( AF_INET, ip, &address.sin_addr );
29. address.sin_port = htons( port );
30.
31. int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
32. assert( listenfd >= 0 );
33.
34. struct sockaddr* )&address, sizeof( address ) );
35. assert( ret != -1 );
36.
37. ret = listen( listenfd, 5 );
38. assert( ret != -1 );
39.
40. struct sockaddr_in client_address;
41. sizeof( client_address );
42. int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
43. if ( connfd < 0 )
44. {
45. "errno is: %d\n", errno );
46. close( listenfd );
47. }
48.
49. char remote_addr[INET_ADDRSTRLEN];
50. "connected with ip: %s and port: %d\n",
51. inet_ntop( AF_INET, &client_address.sin_addr, remote_addr, INET_ADDRSTRLEN ),
52. ntohs( client_address.sin_port ) );
53.
54. char buf[1024];
55. fd_set read_fds;
56. fd_set exception_fds;
57.
58. FD_ZERO( &read_fds );
59. FD_ZERO( &exception_fds );
60.
61. int nReuseAddr = 1;
62. sizeof( nReuseAddr ) );
63. while( 1 )
64. {
65. '\0', sizeof( buf ) );
66. /* 每次调用select前都要重新在readfds和exception_fds中设置文件描述符connfd，因为事件发生之后，文件描述符集合将被内核修改 */
67. FD_SET( connfd, &read_fds );
68. FD_SET( connfd, &exception_fds );
69.
70. ret = select( connfd + 1, &read_fds, NULL, &exception_fds, NULL );
71. "select one\n" );
72. if ( ret < 0 )
73. {
74. "selection failure\n" );
75. break;
76. }
77.
78. /* 对于可读事件，采用普通的recv函数读取数据 */
79. if ( FD_ISSET( connfd, &read_fds ) )
80. {
81. sizeof( buf )-1, 0 );
82. if( ret <= 0 )
83. {
84. break;
85. }
86. "get %d bytes of normal data: %s\n", ret, buf );
87. }
88. /* 对于异常事件，采用带MSG_OOB标志的recv函数读取带外数据 */
89. else if( FD_ISSET( connfd, &exception_fds ) )
90. {
91. sizeof( buf )-1, MSG_OOB );
92. if( ret <= 0 )
93. {
94. break;
95. }
96. "get %d bytes of oob data: %s\n", ret, buf );
97. }
98.
99. }
100.
101. close( connfd );
102. close( listenfd );
103. return 0;
104. }
poll系统调用
作用：和select类型，也是在指定时间内轮询一定数量的文件描述符，以测试其中是否有就绪者。
原型：
1. #include <poll.h>
2. int poll ( struct pollfd* fds, nfds_t nfds, int timeout );
函数说明：
- fds：一个pollfd结构类型的数组，指定我们所感兴趣的文件描述符上发生的可读，可写和异常事件。
pollfd结构：
1. struct pollfd
2. {
3. int fd; /* 文件描述符 */
4. short events; /* 注册的事件 */
5. short revents; /* 实际发生的事件，由内核填充 */
6. }
- nfds ：指定被监听事件集合fds的大小。其类型nfds_t 的定义如下：
1. typedef unsigned long int nfds_t;
- timeout ：指定poll的超时值，单位是毫秒。当timeout 为-1时，poll调用将永远阻塞，直到某个事件发生；当timeout为0时，poll调用将立即返回。
poll系统调用轮询描述符的数量的限制：一个进程所能打开的最大文件描述符有关。可以通过调整内核参数、ulimit -n命令、setrlimit函数。
- 一个系统所能打开的文件描述符的最大数也是有限制的，跟内存有关，可以通过 /proc/sys/fs/file-max 调整。
- 一个进程所能打开的文件描述符最大值，可以通过调整内核参数、ulimit -n命令、setrlimit函数。
epoll系列系统调用
特点：
一组函数完成任务
epoll把用户关心的文件描述符上的事件放在内核里的一个事件表中，从而无须像select和poll那样每次调用都要重复传入文件描述符集或事件集。
需要一个额外的文件描述来唯一标识内核中的这个事件表。
文件描述符的创建：
1. #include <sys/epoll.h>
2. int epoll_create ( int size );
该函数返回的文件描述符将用作其他所有epoll系统调用的第一个参数，以指定要访问的内核事件表。
操作内核事件表：
1. #include <sys/epoll.h>
2. int epoll_ctl ( int epfd, int op, int fd, struct epoll_event *event );
函数说明：
fd：要操作的文件描述符
op：指定操作类型
操作类型：
EPOLL_CTL_ADD：往事件表中注册fd上的事件
EPOLL_CTL_MOD：修改fd上的注册事件
EPOLL_CTL_DEL：删除fd上的注册事件
event：指定事件，它是epoll_event结构指针类型
epoll_event定义：
1. struct epoll_event
2. {
3. /* epoll事件 */
4. /* 用户数据 */
5. };
结构体说明：
events：描述事件类型，和poll支持的事件类型基本相同（两个额外的事件：EPOLLET和EPOLLONESHOT，高效运作的关键）
data成员：存储用户数据
1. typedef union epoll_data
2. {
3. void* ptr; /* 指定与fd相关的用户数据 */
4. int fd; /* 指定事件所从属的目标文件描述符 */
5. uint32_t u32;
6. uint64_t u64;
7. } epoll_data_t;
epoll_wait函数
主要接口
作用：在一段时间内，等待一组文件描述符上的事件
原型：
1. #include <sys/epoll.h>
2. int epoll_wait ( int epfd, struct epoll_event* events, int maxevents, int timeout );
函数说明：
返回：成功时返回就绪的文件描述符的个数，失败时返回-1并设置errno
timeout：与poll相同
maxevents：指定最多监听多少个事件
events：检测到事件，将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中。与poll的区别（见下面的demo）
poll和epoll在使用上的差别：
1. /* 索引poll返回的就绪文件描述符 */
2. /* 方式：遍历，检查标志位 */
3. int ret = poll ( fds, MAX_EVENT_NUMBER, -1 );
4. for ( int i = 0; i < MAX_EVENT_NUMBER; ++i )
5. {
6. if ( fds[i].revents & POLLIN )
7. {
8. int sockfd = fds[i].fd;
9. /* 处理sockfd */
10. }
11. }
12.
13. /* 索引epoll返回的就绪文件描述符 */
14. /* 方式：遍历 */
15. int ret = epoll_wait ( epollfd, events, MAX_EVENT_NUMBER, -1 );
16. for ( int i = 0; i < ret; i++ )
17. {
18. int sockfd = events[i].data.fd;
19. /* sockfd必然就绪，直接处理 */
20. }
LT和ET模式
对文件操作符的操作模式：
- LT：电平触发，默认的工作模式。当epoll_wait检测到其上有事件发生并将此事件通知应用程序后，应用程序可以不立即处理该事件。这样，当应用程序下一次调用epoll_wait时，epoll_wait还会再次向应用程序通告此事件，直到该事件被处理。
- ET：边沿触发，高效工作模式。文件描述符注册为EPOLLET事件，当epoll_wait检测到其上有事件发生并将此事件通知应用程序后，应用程序必须立即处理该事件，因为后续的epoll_wait调用将不再向应用程序通知这一事件。
区别：ET模式在很大程度上降低了同一个epoll事件被重复出发的参数，因此效率要比LT模式高。
注意：ET 模式要求socket为非阻塞模式，如果是阻塞的，那么读或写操作将会因为没有后续事件而一直处于阻塞状态（饥渴状态）。LT模式可以是阻塞或者非阻塞。
1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <string.h>
5. #include <errno.h>
6. #include <fcntl.h>
7. #include <assert.h>
8. #include <sys/socket.h>
9. #include <sys/types.h>
10. #include <sys/epoll.h>
11. #include <netinet/in.h>
12. #include <arpa/inet.h>
13.
14. #define MAX_EVENT_NUMBER 1024
15. #define BUFFER_SIZE 10
16.
17. int setnonblocking(int fd);
18. void addfd(int epollfd, int fd, bool enable_et);
19. void lt(epoll_event *events, int number, int epollfd, int listenfd);
20. void et(epoll_event *events, int number, int epollfd, int listenfd);
21.
22. /*
23. * 用telnet到这个服务端程序上，并一次传输超过10字节(BUFFER_SIZE的大小)的数据，
24. * 然后比较LT和ET的异同，会发现ET比LT下事件被触发的次数少很多。
25. */
26. int main(int argc, char **argv)
27. {
28. if (argc != 3) {
29. "Usage: %s ip port\n", basename(argv[0]));
30. return 1;
31. }
32.
33. const char *ip = argv[1];
34. int port = atoi(argv[2]);
35.
36. int ret = 0;
37.
38. struct sockaddr_in address;
39. sizeof(address));
40. address.sin_family = AF_INET;
41. address.sin_port = htons(port);
42. inet_pton(AF_INET, ip, &address.sin_addr);
43.
44. int sockfd = socket(PF_INET, SOCK_STREAM, 0);
45. assert(sockfd >= 0);
46.
47. int reuse = 1;
48. sizeof(reuse));
49.
50. struct sockaddr*)&address, sizeof(address));
51. assert(ret != -1);
52.
53. ret = listen(sockfd, 5);
54. assert(ret != -1);
55.
56. epoll_event events[MAX_EVENT_NUMBER];
57. int epollfd = epoll_create(5);
58. assert(epollfd != -1);
59.
60. true);
61.
62. while (1) {
63. int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
64. if (ret < 0) {
65. "epoll failed: %s\n", strerror(errno));
66. break;
67. }
68.
69. //lt(events, ret, epollfd, sockfd); //LT模式
70. //ET模式
71. }
72. close(epollfd);
73. close(sockfd);
74.
75. return 0;
76. }
77.
78. //设置非阻塞文件描述符
79. int setnonblocking(int fd)
80. {
81. int old_option = fcntl(fd, F_GETFL);
82. int new_option = old_option | O_NONBLOCK;
83. fcntl(fd, F_SETFL, new_option);
84. return old_option;
85. }
86.
87. //将描述符fd的EPOLLIN注册到epollfd提示的epoll内核事件中，参数enable_et指定是否启用ET模式
88. void addfd(int epollfd, int fd, bool enable_et)
89. {
90. epoll_event event;
91. event.data.fd = fd;
92. event.events = EPOLLIN;
93.
94. if (enable_et) {
95. event.events |= EPOLLET;
96. }
97.
98. epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
99.
100. setnonblocking(fd);
101. }
102.
103. //LT模式
104. void lt(epoll_event *events, int number, int epollfd, int listenfd)
105. {
106. char buf[BUFFER_SIZE];
107.
108. for (int i = 0; i < number; i++) {
109. int sockfd = events[i].data.fd;
110. if (sockfd == listenfd) {
111. struct sockaddr_in client_address;
112. sizeof(client_address);
113.
114. int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
115. false);
116. }
117. else if (events[i].events & EPOLLIN) { //只要socket读缓存中还有未读出的数据，就会被触发
118. "event trigger once\n");
119. '\0', BUFFER_SIZE);
120.
121. int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
122. if (ret <= 0) {
123. close(sockfd);
124. continue;
125. }
126.
127. "get %d bytes of content: %s\n", ret, buf);
128. }
129. else {
130. "something else happened\n");
131. }
132. }
133. }
134.
135. //ET模式
136. void et(epoll_event *events, int number, int epollfd, int listenfd)
137. {
138. char buf[BUFFER_SIZE];
139.
140. for (int i = 0; i < number; i++) {
141. int sockfd = events[i].data.fd;
142. if (sockfd == listenfd) {
143. struct sockaddr_in client_address;
144. sizeof(client_address);
145.
146. int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
147. true);
148. }
149. else if (events[i].events & EPOLLIN) {
150. "event trigger once\n");
151. int ret = 0;
152.
153. //因为ET模式不会重复触发，所以我们要循环读取所有数据
154. while (1) {
155. '\0', BUFFER_SIZE);
156.
157. ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
158. if (ret < 0) {
159. //对于非阻塞I/O，下面的条件成立时表示数据已全部读取完毕
160. if (errno == EAGAIN || errno == EWOULDBLOCK) {
161. "read later!\n");
162. break;
163. }
164.
165. close(sockfd);
166. break;
167. }
168. else if (ret == 0) {
169. close(sockfd);
170. }
171. else {
172. "get %d bytes of content: %s\n", ret, buf);
173. }
174.
175. }
176.
177. }
178. else {
179. "something else happened\n");
180. }
181. }
182.
183. }
EPOLLONESHOT事件
使用场合：
于是，就出现了两个线程同时操作一个socket的局面。
可以使用epoll的EPOLLONESHOT事件实现一个socket连接在任一时刻都被一个线程处理。
对于注册了EPOLLONESHOT事件的文件描述符，操作系统最多触发其上注册的一个可读、可写或异常事件，且只能触发一次，除非我们使用epoll_ctl函数重置该文件描述符上注册 的EPOLLONESHOT事件。
使用：
注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕，该线程就应该立即重置这个socket上的EPOLLONESHOT事件，以确保这个socket下一次可读时，其EPOLLIN事件能被触发，进而让其他工作线程有机会继续处理这个socket。
效果：
尽管一个socket在不同事件可能被不同的线程处理，但同一时刻肯定只有一个线程在为它服务，这就保证了连接的完整性，从而避免了很多可能的竞态条件。
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 1024
struct fds
{
int epollfd;
int sockfd;
};
int setnonblocking( int fd )
{
int old_option = fcntl( fd, F_GETFL );
int new_option = old_option | O_NONBLOCK;
fcntl( fd, F_SETFL, new_option );
return old_option;
}
/*将fd上的EPOLLIN和EPOLLET事件注册到epollfd指示的epoll内核事件表中，参数oneshot指定是否注册fd上的EPOLLONESHOT事件*/
void addfd( int epollfd, int fd, bool oneshot )
{
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET;
if( oneshot )
{
event.events |= EPOLLONESHOT;
}
epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );
setnonblocking( fd );
}
/*重置fd上的事件。这样操作之后，尽管fd上的EPOLLONESHOT事件被注册，但是操作系统仍然会触发fd上的EPOLLIN事件，且只触发一次 */
void reset_oneshot( int epollfd, int fd )
{
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
epoll_ctl( epollfd, EPOLL_CTL_MOD, fd, &event );
}
/*工作线程*/
void* worker( void* arg )
{
int sockfd = ( (fds*)arg )->sockfd;
int epollfd = ( (fds*)arg )->epollfd;
printf( "start new thread to receive data on fd: %d\n", sockfd );
char buf[ BUFFER_SIZE ];
memset( buf, '\0', BUFFER_SIZE );
/*循环读取sockfd上的数据，直到遇到EAGAIN错误*/
while( 1 )
{
int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
if( ret == 0 )
{
close( sockfd );
printf( "foreiner closed the connection\n" );
break;
}
else if( ret < 0 )
{
if( errno == EAGAIN )
{
reset_oneshot( epollfd, sockfd );
printf( "read later\n" );
break;
}
}
else
{
printf( "get content: %s\n", buf );
/*休眠5S，模拟数据处理过程 */
sleep( 5 );
}
}
printf( "end thread receiving data on fd: %d\n", sockfd );
}
int main( int argc, char* argv[] )
{
if( argc <= 2 )
{
printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
return 1;
}
const char* ip = argv[1];
int port = atoi( argv[2] );
int ret = 0;
struct sockaddr_in address;
bzero( &address, sizeof( address ) );
address.sin_family = AF_INET;
inet_pton( AF_INET, ip, &address.sin_addr );
address.sin_port = htons( port );
int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
assert( listenfd >= 0 );
ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
assert( ret != -1 );
ret = listen( listenfd, 5 );
assert( ret != -1 );
epoll_event events[ MAX_EVENT_NUMBER ];
int epollfd = epoll_create( 5 );
assert( epollfd != -1 );
/*注意，监听socket listenfd上是不能注册RPOLLONESHOT事件的，否则应用程序只能处理一个客户连接！因为后续的客户连接请求将不再触发listenfd上的EPOLLIN事件*/
addfd( epollfd, listenfd, false );
while( 1 )
{
int ret = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, -1 );
if ( ret < 0 )
{
printf( "epoll failure\n" );
break;
}
for ( int i = 0; i < ret; i++ )
{
int sockfd = events[i].data.fd;
if ( sockfd == listenfd )
{
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof( client_address );
int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
/*对每个非监听文件描述符都注册EPOLLONESHOT事件*/
addfd( epollfd, connfd, true );
}
else if ( events[i].events & EPOLLIN )
{
pthread_t thread;
fds fds_for_new_worker;
fds_for_new_worker.epollfd = epollfd;
fds_for_new_worker.sockfd = sockfd;
/*新启动一个工作线程为sockfd服务*/
pthread_create( &thread, NULL, worker, ( void* )&fds_for_new_worker );
}
else
{
printf( "something else happened \n" );
}
}
}
close( listenfd );
close( epollfd );
return 0;
}
小结：三组I/O复用函数的比较
系统调用 | select | poll | epoll |
事件集合 | 用户通过3个参数分别传入感兴趣的可读、可写及异常等事件，
内核通过对这些参数的在线修改来反馈其中的就绪事件。
这使得用户每次调用select都要重置这3个参数 | 统一处理所有事件类型，因此只需要一个事件集参数。
用户通过pollfd.events传入感兴趣的事件，内核通过
修改pollfd.revents反馈其中就绪的事件 | 内核通过一个事件表直接管理用户感兴趣的所有事件。
因此每次调用epoll_wait时，无需反复传入用户感兴趣
的事件。epoll_wait系统调用的参数events仅用来反馈就绪的事件 |
应用程序索引就绪文件
描述符的时间复杂度 | O(n) | O(n) | O(1) |
最大支持文件描述符数 | 一般有最大值限制（ FD_SETSIZE 为1024，修改后需重新编译内核) | 65535（ 一个进程所能打开的最大文件描述符数量，ulimit -n或者setrlimit函数） | 65535（ 系统能打开的最大文件描述符数量，/proc/sys/fs/file-max） |
工作模式 | LT | LT | 支持ET高效模式
|
内核实现和工作效率 | 采用轮询方式检测就绪事件
时间复杂度：O(n) |
采用轮询方式检测就绪事件
时间复杂度：O(n)
| 采用回调方式检测就绪事件
事件复杂度：O(1) |
对于poll函数，内核每次修改的是pollfd结构体的revents成员，而events成员保持不变，因此下次调用poll时应用程序无须重置pollfd类型的事件集参数。由于每次select和poll调用都返回整个用户注册的事件集合（其中包括就绪的和围酒席的），所以应用程序索引就绪文件描述符的时间复杂度为O(n)。epoll则采用与select和poll完全不同的方式来管理用户注册的事件。它在内核中维护一个事件表，并提供了一个独立的系统调用epoll_ctl来控制往其中添加、删除、修改事件。这样每次epoll_wait调用都直接从该内核事件表中取得用户注册的事件，而无须反复从用户空间读入这些事件。epoll_wait系统调用的events参数仅用来返回就绪的事件，这使得应用程序索引的就绪文件描述符的时间复杂度达到0(1)。
需要说明的是：
当活动连接比较多的时候，epoll_wait的效率未必比select和poll高，因为此时回调函数被触发的过于频繁。
所以，epoll_wait适用于连接数量多，但活动连接较少的情况。
参考资料：
《Linux高性能服务器编程》
