I/O多路复用
IO多路复用（IO Multiplexing）一种同步IO模型，单个进程/线程就可以同时处理多个IO请求。一个进程/线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序，交出cpu。多路是指网络连接，复用指的是同一个进程/线程。
一个进程/线程虽然任一时刻只能处理一个请求，但是处理每个请求的事件时，耗时控制在 1 毫秒以内，这样 1 秒内就可以处理上千个请求，把时间拉长来看，多个请求复用了一个进程/线程，这就是多路复用，这种思想很类似一个 CPU 并发多个进程，所以也叫做时分多路复用。
系统调用主要有 select、poll 和 epoll
主要使用的方法有三种:
select
主旨思想:
-
首先要构造一个关于文件描述符的列表，将要监听的文件描述符添加到该列表中。
-
调用一个系统函数，监听该列表中的文件描述符，直到这些描述符中的一个或者多个进行I/O 操作时，该函数才返回。
a.这个函数是阻塞
b.函数对文件描述符的检测的操作是由内核完成的
3. 在返回时，它会告诉进程有多少(哪些)描述符要进行I/O操作。
函数原型：
// sizeof(fd_set) = 128 1024 #include <sys/time.h> #include <sys/types.h> #include <unistd.h> #include <sys/select.h> 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; /* seconds */ long tv_usec; /* microseconds */ }; - 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);
select实现tcp服务端：
#include <stdio.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/select.h> 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 = %s\n", buf); write(i, buf, strlen(buf) + 1); } } } } } close(lfd); return 0; }
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <arpa/inet.h> #include <ctype.h> #include "wrap.h" #define SERV_PORT 6666 int main(int argc, const char *argv[]) { int i, j, n, maxi; int nready, client[FD_SETSIZE]; int maxfd, listenfd, connfd, sockfd; int buf[BUFSIZ], str[INET_ADDRSTRLEN]; struct sockaddr_in clie_addr, serv_addr; socklen_t clie_addr_len; fd_set rset, allset; listenfd = Socket(AF_INET, SOCK_STREAM, 0); bzero(&serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); serv_addr.sin_port = htons(SERV_PORT); Bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); Listen(listenfd, 20); maxfd = listenfd //起初listenfd为最大文件描述符 maxi = -1; for(i=0; i<FD_SETSIZE; i++) client[i] = -1; FD_ZERO(&allset); FD_SET(listenfd, &allset); //把服务端socket文件描述符加入监控文件描述符集合中 while(1){ rset = allset; nready = select(maxfd+1, &rset, NULL, NULL, NULL); //阻塞监听读事件集合 if(nready < 0) perr_exit("select error"); //判断listenfd是否在rset中，如果在表示有新的客户端链接请求 if(FD_ISSET(listenfd, &rset)){ clie_addr_len = sizeof(clie_addr); connfd = Accept(listenfd, (struct sockaddr*)&clie_addr, &clie_addr_len); //立即连上客户端，不会阻塞 printf("received from %s at PORT %d\n", inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)), ntohs(clie_addr.sin_port)); for(i=0; i<FD_SETSIZE; i++){ if(client[i] < 0){ client[i] = connfd; break; } } if(i == FD_SETSIZE){ //达到select能监控的文件描述符上限（1024） fputs("too many clients\n", stderr); exit(1); } FD_SET(connfd, &allset); //把客户端文件描述符加入监控文件描述符集合中 if(connfd > maxfd) maxfd = connfd; if(i > maxi) maxi = i; if(--nready == 0) continue; } for(i=0; i<=maxi; i++){ //检测哪个client有数据就绪 if((sockfd = client[i]) < 0) continue; if(FD_ISSET(sockfd, &rset)){ if((n = Read(sockfd, buf, sizeof(buf))) == 0){ //当client关闭连接时，服务端也关闭对应连接 Close(sockfd); FD_CLR(sockfd, &allset); //解除select对此文件描述符的监控 } else if(n > 0){ for(j=0; j<n; j++) buf[j] = toupper(buf[j]); sleep(10); Write(sockfd, buf, n); } if(--nready == 0) break; } } } }
select缺点
1.每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
2.同时每次调用select都需要在内核遍历 传递进来的所有fd，这个开销在fd很多时也很大
3.select支持的文件描述符数量太小了， 默认是1024
4.fds集合不能重用，每次都需要重置
poll
poll的原理和select基本相同，但是改进了select的一些缺点：
1. 可以支持1024以上的文件描述符
2. 数组可以复用
#include <poll.h> 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个文件描述符发生变化
poll实现tcp服务端
#include <stdio.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <poll.h> 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 = %s\n", buf); write(fds[i].fd, buf, strlen(buf) + 1); } } } } } close(lfd); return 0; }
epoll
基础API
#include <sys/epoll.h> // 创建一个新的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
epoll实现server端
#include <stdio.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/epoll.h> 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 = %d\n", 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) { printf("client closed...\n"); epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL); close(curfd); } else if(len > 0) { printf("read buf = %s\n", buf); write(curfd, buf, strlen(buf) + 1); } } } } close(lfd); close(epfd); return 0; }
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <arpa/inet.h> #include <ctype.h> #include <errno.h> #include <sys/epoll.h> #include "wrap.h" #define SERV_PORT 6666 #define MAXLINE 8192 #define OPEN_MAX 5000 int main(int argc, const char *argv[]) { int i, n, num = 0; int listenfd, connfd, sockfd; ssize_t nready, efd, res; int buf[BUFSIZ], str[INET_ADDRSTRLEN]; struct sockaddr_in clie_addr, serv_addr; socklen_t clie_addr_len; struct epoll_event tep, ep[open_max]; listenfd = Socket(AF_INET, SOCK_STREAM, 0); int opt = 1; setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); //端口复用 bzero(&serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); serv_addr.sin_port = htons(SERV_PORT); Bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); Listen(listenfd, 20); efd = epoll_create(OPEN_MAX); //创建epoll模型，efd指向红黑树根节点 if(efd == -1) perr_exit("epoll create error"); tep.events = EPOLLIN; //指定lfd的监听时间为读 tep.data.fd = listend; res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep); //将lfd及对应的结构体设置到树上，efd可找到该树 if(res == -1) perr_exit("epoll_ctl error"); while(1){ //epoll为server阻塞监听事件，ep为struct epoll_event类型数组，OPEN_MAX为数组容量，-1表示永久阻塞 nready = epoll_wait(efd, ep, OPEN_MAX, -1); //阻塞监听读事件集合 if(nready == 1) perr_exit("epoll_wait error"); //判断listenfd是否在rset中，如果在表示有新的客户端链接请求 for(i=0; i<nready; i++){ if(!(ep[i].events & EPOLLIN)) continue; //如果不是读事件就跳过 if(ep[i].data.fd == listenfd){ //判断满足事件的fd是不是lfd clie_addr_len = sizeof(clie_addr); connfd = Accept(listenfd, (struct sockaddr*)&clie_addr, &clie_addr_len); //立即连上客户端，不会阻塞 printf("received from %s at PORT %d\n", inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)), ntohs(clie_addr.sin_port)); tep.events = EPOLLIN; //指定lfd的监听时间为读 tep.data.fd = listend; res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep); //将lfd及对应的结构体设置到树上，efd可找到该树 if(res == -1) perr_exit("epoll_ctl error"); } else{ sockfd = ep[i].data.fd; n = Read(sockfd, buf, MAXLINE); if(n == 0){ //0表示客户端关闭连接 res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL); //将该文件描述符从红黑树中摘除 if(res == -1) perr_exit("epoll_ctl error"); Close(sockfd); } else if(n < 0){ perror("read error"); res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL); Close(sockfd); } else{ for(i=0; i<n; i++) buf[i] = toupper(buf[i]); Write(sockfd, buf, n); Write(STDOUT_FILENO, buf, n); } } } } }
参考资料
