I/O 多路复用使得程序能同时监听多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用的系统调用主要有 select、poll 和 epoll。
1、select
1.1 主旨思想
1）首先要构造一个关于文件描述符的列表，将要监听的文件描述符添加到该列表中。
2）调用一个系统函数，监听该列表中的文件描述符，直到这些描述符中的一个或者多个进行I/O操作时，该函数才返回。
a.这个函数是阻塞的
b.函数对文件描述符的检测的操作是由内核完成的
3）在返回时，它会告诉进程有多少（哪些）描述符要进行I/O操作。
1.2 相关API
// sizeof(fd_set) = 128个字节， 1024位
#include
#include
#include
#include
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
- 参数：
- nfds : 委托内核检测的最大文件描述符的值 + 1
- readfds : 要检测的文件描述符的读的集合，委托内核检测哪些文件描述符的读的属性
- 一般检测读操作
- 对应的是对方发送过来的数据，因为读是被动的接收数据，检测的就是读缓冲区
- 是一个传入传出参数
- writefds : 要检测的文件描述符的写的集合，委托内核检测哪些文件描述符的写的属性
- 委托内核检测写缓冲区是不是还可以写数据（不满的就可以写）
- exceptfds : 检测发生异常的文件描述符的集合
- timeout : 设置的超时时间
struct timeval {
long tv_sec;
long tv_usec;
};
- NULL : 永久阻塞，直到检测到了文件描述符有变化
- tv_sec = 0 tv_usec = 0， 不阻塞
- tv_sec > 0 tv_usec > 0， 阻塞对应的时间
- 返回值 :
- -1 : 失败
- >0(n) : 检测的集合中有n个文件描述符发生了变化
// 将参数文件描述符fd对应的标志位设置为0
void FD_CLR(int fd, fd_set *set);
// 判断fd对应的标志位是0还是1， 返回值 ： fd对应的标志位的值，0，返回0， 1，返回1
int FD_ISSET(int fd, fd_set *set);
// 将参数文件描述符fd 对应的标志位，设置为1
void FD_SET(int fd, fd_set *set);
// fd_set一共有1024 bit, 全部初始化为0
void FD_ZERO(fd_set *set);
1.3 工作过程分析
客户端 A 、B、C 和 D 连接到服务器，用户态会构造一个用于存放文件描述符的列表 reads ，并且使用 FD_SET 将这四个客户端对应的文件描述符标志位置为 1 （即 3、4、100 和 101 标志位置为1）。之后调用 select ，select 会将 fd_set 从用户态拷贝到内核态，内核遍历整个 fd_set ，内核需要去检测标志位为 1 的文件描述符。假设这时 A 和 B 发送了数据，那么 A 和 B 对应的文件描述符的缓冲区有数据。如果内核检测到标志位为 1 的文件描述符缓冲区有数据，那么将其重新置为1，否则置为 0（图中 3 和 4 的标志位置为1，100 和 101 的标志位置为 0）。然后将 fd_set 从内核态拷贝到用户态，用户态遍历 fd_set ，如果标志位为 1 ，那么就去读数据/写数据。
1.4 案例
下面是一个用户端与服务器端通信的案例（2个程序），实现用户端与服务端建立连接，用户端发送数据，服务器接收数据的功能。
#include#include #include #include #include #include int main() { // 创建socket int lfd = socket(PF_INET, SOCK_STREAM, 0); struct sockaddr_in saddr; saddr.sin_port = htons(9999); saddr.sin_family = AF_INET; saddr.sin_addr.s_addr = INADDR_ANY; // 绑定 bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr)); // 监听 listen(lfd, 8); // 创建一个fd_set的集合，存放的是需要检测的文件描述符 fd_set rdset, tmp; FD_ZERO(&rdset); FD_SET(lfd, &rdset); int maxfd = lfd; while(1) { tmp = rdset; // 调用select系统函数，让内核帮检测哪些文件描述符有数据 int ret = select(maxfd + 1, &tmp, NULL, NULL, NULL); if(ret == -1) { perror("select"); exit(-1); } else if(ret == 0) { continue; } else if(ret > 0) { // 说明检测到了有文件描述符的对应的缓冲区的数据发生了改变 if(FD_ISSET(lfd, &tmp)) { // 表示有新的客户端连接进来了 struct sockaddr_in cliaddr; int len = sizeof(cliaddr); int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len); // 将新的文件描述符加入到集合中 FD_SET(cfd, &rdset); // 更新最大的文件描述符 maxfd = maxfd > cfd ? maxfd : cfd; } for(int i = lfd + 1; i <= maxfd; i++) { if(FD_ISSET(i, &tmp)) { // 说明这个文件描述符对应的客户端发来了数据 char buf[1024] = {0}; int len = read(i, buf, sizeof(buf)); if(len == -1) { perror("read"); exit(-1); } else if(len == 0) { printf("client closed...n"); close(i); FD_CLR(i, &rdset); } else if(len > 0) { printf("read buf = %sn", buf); write(i, buf, strlen(buf) + 1); } } } } } close(lfd); return 0; }
注：1）每打开一个新文件，则占用一个文件描述符，而且是空闲的最小的一个文件描述符。所以用于监听的文件描述符 lfd 小于用于通信的文件描述符 cfd ，所以 for 循环里 i 从 lfd + 1 到 maxfd
2）rdset 用于用户区，temp 用于内核区
3）先建立一个用于存放文件描述符的列表 rdset ，将监听文件描述符 lfd 对应的标志位置为1，再调用 select ，将 temp 复制到内核区（为避免内核区对 rdset 进行直接操作，比如在 1.3 中，内核态将 fd_set 拷贝到用户态后，100 和 101 对应的标志位为 0 ，那么下次再调用 select 后，100 和 101 仍为 0 ，内核不会检测 C 和 D 是否发送了数据，所以 1.4 中用到了 temp）。如果有连接请求（有新的客户端进来），那么 lfd 对应的读缓冲区就有数据，然后使用 accept 返回通信文件描述符 cfd ，然后在用户区的 rdset 中将 cfd 对应的标志位置1。然后用户区遍历 rdset ，如果标志位为 1（排除 lfd 对应的标志位），那么就读数据/写数据 。
2、poll
2.1 主旨思想 & 工作过程
poll 的实现和 select 非常相似，只是描述 fd 集合的方式不同，poll 使用 pollfd 结构而不是 select 的 fd_set 结构，其他的都差不多。（可以参考 2.3 中的案例分析）
2.2 相关API
#include
struct pollfd {
int fd;
short events;
short revents;
};
struct pollfd myfd;
myfd.fd = 5;
myfd.events = POLLIN | POLLOUT;
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
- 参数：
- fds : 是一个struct pollfd 结构体数组，这是一个需要检测的文件描述符的集合
- nfds : 这个是第一个参数数组中最后一个有效元素的下标 + 1
- timeout : 阻塞时长
0 : 不阻塞
-1 : 阻塞，当检测到需要检测的文件描述符有变化，解除阻塞
>0 : 阻塞的时长
- 返回值：
-1 : 失败
>0（n） : 成功,n表示检测到集合中有n个文件描述符发生变化
2.3 案例
下面是一个用户端与服务器端通信的案例（2个程序），实现用户端与服务端建立连接，用户端发送数据，服务器接收数据的功能。
#include#include #include #include #include #include int main() { // 创建socket int lfd = socket(PF_INET, SOCK_STREAM, 0); struct sockaddr_in saddr; saddr.sin_port = htons(9999); saddr.sin_family = AF_INET; saddr.sin_addr.s_addr = INADDR_ANY; // 绑定 bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr)); // 监听 listen(lfd, 8); // 初始化检测的文件描述符数组 struct pollfd fds[1024]; for(int i = 0; i < 1024; i++) { fds[i].fd = -1; // 负数，无效的文件描述符 fds[i].events = POLLIN; } fds[0].fd = lfd; // 监听的文件描述符 int nfds = 0; while(1) { // 调用poll系统函数，让内核帮检测哪些文件描述符有数据 int ret = poll(fds, nfds + 1, -1); if(ret == -1) { perror("poll"); exit(-1); } else if(ret == 0) { continue; } else if(ret > 0) { // 说明检测到了有文件描述符的对应的缓冲区的数据发生了改变 if(fds[0].revents & POLLIN) { // 表示有新的客户端连接进来了 struct sockaddr_in cliaddr; int len = sizeof(cliaddr); int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len); // 将新的文件描述符加入到集合中 for(int i = 1; i < 1024; i++) { if(fds[i].fd == -1) { fds[i].fd = cfd; fds[i].events = POLLIN; break; } } // 更新最大的文件描述符的索引 nfds = nfds > cfd ? nfds : cfd; } for(int i = 1; i <= nfds; i++) { if(fds[i].revents & POLLIN) { // 说明这个文件描述符对应的客户端发来了数据 char buf[1024] = {0}; int len = read(fds[i].fd, buf, sizeof(buf)); if(len == -1) { perror("read"); exit(-1); } else if(len == 0) { printf("client closed...n"); close(fds[i].fd); fds[i].fd = -1; } else if(len > 0) { printf("read buf = %sn", buf); write(fds[i].fd, buf, strlen(buf) + 1); } } } } } close(lfd); return 0; }
注：1）文件描述符存放于 pollfd 结构体中，这个结构体又存放于数组中，数组大小可以任意选取
2）if(fds[i].revents & POLLIN) 中用到 & ，避免了可能出现的 fds[i].revents == POLLIN 中 fds[i].revents = POLLIN | POLLOUT 的情况
3）先构造一个存放 pollfd 结构体元素的数组 fds（数组大小不定），该数组用来存放文件描述符，并将该数组的第 0 号元素设为监听的文件描述符 lfd 。调用 poll ，将整个数组复制到内核区。如果有新客户端进来，那么 fds[0] 对应的读缓冲区就有数据，然后使用 accept 返回通信文件描述符 cfd，然后在用户区的 fds 数组中加入新的文件描述符 cfd。然后用户区遍历 fds，如果委托内核检测文件描述符的事件和文件描述符实际发生的事件相同，那么就读数据/写数据 。
2.4 select 与 poll 比较分析
1、select 的几大缺点：
1）每次调用 select，都需要把 fd 集合从用户态拷贝到内核态，这个开销在 fd 很多时会很大
2）同时每次调用 select 都需要在内核遍历传递进来的所有 fd，这个开销在 fd 很多时也很大
3）select 支持的文件描述符数量太小了，默认是 1024
4）fd 集合不能重用，每次都需要重置
2、poll 相对 select 的改进：
1）poll 使用 pollfd 结构体，然后将 pollfd 结构体放到数组当中，数组大小是任意的。所以 poll 没有最大文件描述符数量的限制
2）fd 集合可以重用，不需要每次都重置
注：poll 保留了 select 的前两个缺点
3、epoll 3.1 工作原理
epoll_create：创建一个 epoll 对象。首先调用 epoll_create 来创建 epoll 的实例 eventpoll（eventpoll 在内核区，没有用户态到内核态的拷贝环节）。结构体 eventpoll 中含有 rbr 和 rdlist 结构体，其中，rbr 是红黑树结构，里面放的是要求检测的文件描述符；rdlist 就绪列表，是双链表结构，里面放的是要求检测的文件描述符里有数据（有数据改变）的那些描述符（或者说已经就绪的文件描述符）。
epoll_ctl：向 epoll 对象中添加要管理的连接。对 epoll 实例进行管理：向 rbr 红黑树上添加文件描述符信息（删除信息，修改信息），然后给内核中断处理程序注册一个回调函数，通知内核，如果这个句柄的数据到了，就把它放到就绪列表 rdlist 中。当内核检测 rbr 中的文件描述符的缓冲区有数据到达时（由于 rbr 是红黑树结构，所以内核遍历它的时候，效率会很高），就调用回调函数将有数据发生改变的文件描述符拷贝到 rdlist 中。
epoll_wait：等待事件的发生。检测函数，检测 rdlist 中是否有数据，将 rdlist 中的数据拷贝到用户区（拷贝的只是就绪的文件描述符，而 select 和 poll 拷贝的是整个 fd_set 或 数组 fds）。然后用户区直接遍历这几个文件描述符，去读数据/写数据。
3.2 相关API#include3.3 案例// 创建一个新的epoll实例。在内核中创建了一个数据，这个数据中有两个比较重要的数据，一个是需要检测的文件描述符的信息（红黑树），还有一个是就绪列表，存放检测到数据发送改变的文件描述符信息（双向链表）。 int epoll_create(int size); - 参数： size : 目前没有意义了。随便写一个数，必须大于0 - 返回值： -1 : 失败 > 0 : 文件描述符，操作epoll实例的 typedef union epoll_data { void *ptr; int fd; uint32_t u32; uint64_t u64; } epoll_data_t; struct epoll_event { uint32_t events; epoll_data_t data; }; 常见的Epoll检测事件： - EPOLLIN - EPOLLOUT - EPOLLERR // 对epoll实例进行管理：添加文件描述符信息，删除信息，修改信息 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); - 参数： - epfd : epoll实例对应的文件描述符 - op : 要进行什么操作 EPOLL_CTL_ADD: 添加 EPOLL_CTL_MOD: 修改 EPOLL_CTL_DEL: 删除 - fd : 要检测的文件描述符 - event : 检测文件描述符什么事情 // 检测函数 int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout); - 参数： - epfd : epoll实例对应的文件描述符 - events : 传出参数，保存了发生了变化的文件描述符的信息 - maxevents : 第二个参数结构体数组的大小 - timeout : 阻塞时间 - 0 : 不阻塞 - -1 : 阻塞，直到检测到fd数据发生变化，解除阻塞 - > 0 : 阻塞的时长（毫秒） - 返回值： - 成功，返回发送变化的文件描述符的个数 > 0 - 失败 -1
下面是一个用户端与服务器端通信的案例（2个程序），实现用户端与服务端建立连接，用户端发送数据，服务器接收数据的功能。
#include#include #include #include #include #include int main() { // 创建socket int lfd = socket(PF_INET, SOCK_STREAM, 0); struct sockaddr_in saddr; saddr.sin_port = htons(9999); saddr.sin_family = AF_INET; saddr.sin_addr.s_addr = INADDR_ANY; // 绑定 bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr)); // 监听 listen(lfd, 8); // 调用epoll_create()创建一个epoll实例 int epfd = epoll_create(100); // 将监听的文件描述符相关的检测信息添加到epoll实例中 struct epoll_event epev; epev.events = EPOLLIN; epev.data.fd = lfd; epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev); struct epoll_event epevs[1024]; // 保存了发生了变化的文件描述符的信息 while(1) { int ret = epoll_wait(epfd, epevs, 1024, -1); if(ret == -1) { perror("epoll_wait"); exit(-1); } printf("ret = %dn", ret); for(int i = 0; i < ret; i++) { int curfd = epevs[i].data.fd; if(curfd == lfd) { // 监听的文件描述符有数据达到，有客户端连接 struct sockaddr_in cliaddr; int len = sizeof(cliaddr); int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len); epev.events = EPOLLIN; epev.data.fd = cfd; epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev); } else { if(epevs[i].events & EPOLLOUT) { continue; } // 有数据到达，需要通信 char buf[1024] = {0}; int len = read(curfd, buf, sizeof(buf)); if(len == -1) { perror("read"); exit(-1); } else if(len == 0) { // 对方关闭连接，从epoll实例中删除该文件描述符 printf("client closed...n"); epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL); close(curfd); } else if(len > 0) { printf("read buf = %sn", buf); write(curfd, buf, strlen(buf) + 1); } } } } close(lfd); close(epfd); return 0; }
注：1）epoll_create 在内核区创建一个 epoll 实例，将监听的文件描述符相关的检测信息使用 epoll_ctl 添加到 epoll 实例中（实际上加到 rbr 中）。之后内核检测 rbr 中的文件描述符（此时是 lfd）的缓冲区是否有数据到达，如果有数据到达，那么有客户连接。然后调用 accept 函数返回通信文件描述符 cfd ，将 cfd 添加到 epoll 实例中（实际上加到 rbr 中）。之后 while 循环，内核检测 rbr 中的文件描述符（即 lfd 和 cfd）的缓冲区是否有数据到达，如果 lfd 缓冲区有数据到达，那么有客户连接，如果 cfd 缓冲区有数据到达，那么将 cfd 拷贝到 rdlist 中，之后调用 epoll_wait 将 rdlist 中的文件描述符拷贝到用户区，去读数据/写数据。周而复始。
3.4 epoll 的工作模式1、LT 模式 （水平触发）
假设委托内核检测读事件 -> 检测fd的读缓冲区
读缓冲区有数据 - > epoll检测到了会给用户通知
a.用户不读数据，数据一直在缓冲区，epoll 会一直通知
b.用户只读了一部分数据，epoll会通知
c.缓冲区的数据读完了，不通知
LT（level - triggered）是缺省的工作方式，并且同时支持 block 和 no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的 fd 进行 IO 操作。如果你不作任何操作，内核还是会继续通知你的。
2、ET 模式（边沿触发）
假设委托内核检测读事件 -> 检测fd的读缓冲区
读缓冲区有数据 - > epoll检测到了会给用户通知
a.用户不读数据，数据一致在缓冲区中，epoll下次检测的时候就不通知了
b.用户只读了一部分数据，epoll不通知
c.缓冲区的数据读完了，不通知
ET（edge - triggered）是高速工作方式，只支持 no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了。但是请注意，如果一直不对这个 fd 作 IO 操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once）。
ET 模式在很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。epoll工作在 ET 模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
水平触发是默认的，而边沿触发需要手动设置。
3.5 select/poll 与 epoll 比较分析1、epoll 通过在内核区创建 epoll 对象，避免了 select/poll 中用户区向内核区拷贝的环节；
2、每次调用 select 和 poll 时，要对 fd 集合进行线性遍历，随着 fd 数量增加，会造成遍历速度线性下降。而 epoll 通过回调函数来对活跃的 fd 进行操作。
3、当连接数较多并且有很多的不活跃连接时，epoll 的效率比其它两者高很多；但是当连接数较少并且都十分活跃的情况下，由于 epoll 需要很多回调，因此性能可能低于其它两者。
参考文献：
1）socket通信过程中的文件描述符
2）深入揭秘 epoll 是如何实现 IO 多路复用的
3）7层网络以及5种Linux IO模型以及相应IO基础
附录1、用户端程序：
#include#include #include #include #include int main() { // 创建socket int fd = socket(PF_INET, SOCK_STREAM, 0); if(fd == -1) { perror("socket"); return -1; } struct sockaddr_in seraddr; inet_pton(AF_INET, "127.0.0.1", &seraddr.sin_addr.s_addr); seraddr.sin_family = AF_INET; seraddr.sin_port = htons(9999); // 连接服务器 int ret = connect(fd, (struct sockaddr *)&seraddr, sizeof(seraddr)); if(ret == -1){ perror("connect"); return -1; } int num = 0; while(1) { char sendBuf[1024] = {0}; sprintf(sendBuf, "send data %d", num++); write(fd, sendBuf, strlen(sendBuf) + 1); // 接收 int len = read(fd, sendBuf, sizeof(sendBuf)); if(len == -1) { perror("read"); return -1; }else if(len > 0) { printf("read buf = %sn", sendBuf); } else { printf("服务器已经断开连接...n"); break; } sleep(1); // usleep(1000); } close(fd); return 0; }
注：select、poll 和 epoll 共用一个 client.c 程序。
