IO多路复用
一、五种网络I/O模型
在Linux下进行网络编程时，我们常常见到同步(Sync)/异步(Async)，阻塞(Block)/非阻塞(Unblock)四种调用方式：
同步和异步的概念描述的是用户线程与内核的交互方式：同步是指用户线程发起IO请求后需要等待或者轮询内核IO操作完成
后才能继续执行；而异步是指用户线程发起IO请求后仍继续执行，当内核IO操作完成后会通知用户线程，或者调用用户线程注册
的回调函数。
阻塞和非阻塞的概念描述的是用户线程调用内核IO操作的方式：阻塞是指IO操作在没有接收完数据或者没有得到结果之前不
会返回，需要彻底完成后才返回到用户空间；而非阻塞是指IO操作被调用后立即返回给用户一个状态值，无需等到IO操作彻底完
成。
在Linux下进行网络编程时，服务器端编程经常需要构造高性能的IO模型，常见的IO模型有五种：
（1）同步阻塞IO（Blocking IO）
（2）同步非阻塞IO（Non-blocking IO）
（3）IO多路复用（IO Multiplexing）
（4）信号驱动IO（signal driven IO）
（5）异步IO（Asynchronous IO）
目前操作系统多为采用IO多路复用的模型模拟异步IO的方式，即我们重点介绍IO多路复用。
IO多路复用：IO多路复用模型是建立在内核提供的多路分离函数select基础之上的，使用select函数可以避免同步非阻塞IO模型中轮询等待的问题，此外poll、epoll都是这种模型。在该种模式下，用户首先将需要进行IO操作的socket添加到select中，然后阻塞等待select系统调用返回。当数据到达时，socket被激活，select函数返回。用户线程正式发起read请求，读取数据并继续执行。从流程上来看，使用select函数进行IO请求和同步阻塞模型没有太大的区别，甚至还多了添加监视socket，以及调用select函数的额外操作，效率更差。但是，使用select以后最大的优势是用户可以在一个线程内同时处理多个socket的IO请求。用户可以注册多个socket，然后不断地调用select读取被激活的socket，即可达到在同一个线程内同时处理多个IO请求的目的。
二、select多路复用
select函数原型如下：
int select (int maxfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
select系统调用是用来让我们的程序监视多个文件句柄(socket 句柄)的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有一个或多个发生了状态改变
#include <sys/select.h>
#include <sys/time.h>
struct timeval
{
long tv_sec; //seconds
long tv_usec; //microseconds
};
FD_ZERO(int fd, fd_set* fds) //清空集合
FD_SET(int fd, fd_set* fds) //将给定的描述符加入集合
FD_ISSET(int fd, fd_set* fds) //判断指定描述符是否在集合中
FD_CLR(int fd, fd_set* fds) //将给定的描述符从文件中删除
int select(int max_fd, fd_set *readset, fd_set *writeset, fd_set *exceptset, struct timeval *timeout);说明： select监视并等待多个文件描述符的属性发生变化，它监视的属性分3类，分别是readfds(文件描述符有数据到来可读)、
writefds(文件描述符可写)、和exceptfds(文件描述符异常)。调用后select函数会阻塞，直到有描述符就绪（有数据可读、可写、
或者有错误异常），或者超时（ timeout 指定等待时间）发生函数才返回。当select()函数返回后，可以通过遍历 fdset，来找到
究竟是哪些文件描述符就绪。
1. select函数的返回值是就绪描述符的数目，超时时返回0，出错返回-1；
2. 第一个参数max_fd指待测试的fd个数，它的值是待测试的最大文件描述符加1。Linux内核从0开始到max_fd-1扫描文件描述符，如果有数据出现事件(读、写、异常)将会返回；假设需要监测的文件描述符是8,9,10，那么Linux内核实际也要监测0~7，此时真正带测试的文件描述符是0~10总共11个，即max(8,9,10)+1，所以第一个参数是所有要监听的文件描述符中最大的+1。
3. 中间三个参数readset、writeset和exceptset指定要让内核测试读、写和异常条件的fd集合，如果不需要测试的可以设为NULL；
4. 最后一个参数是设置select的超时时间，如果设置为NULL则永不超时；
： 待测试的描述集的总个数。 但要注意， 待测试的描述集总是从0， 1， 2， ...开始的。 所以， 假如你要检测的描述符为8，
9， 10， 那么系统实际也要监测0， 1， 2， 3， 4， 5， 6, 7， 此时真正待测试的描述符的个数为11个， 也就是max（8，
9， 10） + 1
在Linux内核有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数中，这也意味着select所用到的FD_SET是有限的，也正是这个原因select()默认只能同时处理1024个客户端的连接请求：
/linux/posix_types.h:
#define __FD_SETSIZE 1024下面是select多路复用实现网络socket服务器多路并发流程图：
使用select多路复用实现网络socket服务器代码：
#include <stdio.h>
#include <stdlib.h>#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
static inline void msleep(unsigned long ms);
static inline void print_usage(char *progname);
int socket_server_init(char *listen_ip, int listen_port);
int main(int argc, char **argv)
{
int listenfd, connfd;
int serv_port = 0;
int daemon_run = 0;
char *progname = NULL;
int opt;
fd_set rdset;
int rv;
int i, j;
int found;
int maxfd=0;
char buf[1024];
int fds_array[1024];
struct option long_options[] =
{
{"daemon", no_argument, NULL, 'b'},
{"port", required_argument, NULL, 'p'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
progname = basename(argv[0]);
/* Parser the command line parameters */
while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
{
switch (opt)
{
case 'b':
daemon_run=1;
break;
case 'p':
serv_port = atoi(optarg);
break;
case 'h': /* Get help information */
print_usage(progname);
return EXIT_SUCCESS;
default:
break;
}
}
if( !serv_port )
{
print_usage(progname);
return -1;}
if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
{
printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
return -2;
}
printf("%s server start to listen on port %d\n", argv[0],serv_port);
/* set program running on background */
if( daemon_run )
{
daemon(0, 0);
}
for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
{
fds_array[i]=-1;
}
fds_array[0] = listenfd;
for ( ; ; )
{
FD_ZERO(&rdset);
for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
{
if( fds_array[i] < 0 )
continue;
maxfd = fds_array[i]>maxfd ? fds_array[i] : maxfd;
FD_SET(fds_array[i], &rdset);
}
/* program will blocked here */
rv = select(maxfd+1, &rdset, NULL, NULL, NULL);
if(rv < 0)
{
printf("select failure: %s\n", strerror(errno));
break;
}
else if(rv == 0)
{
printf("select get timeout\n");
continue;
}
/* listen socket get event means new client start connect now */
if ( FD_ISSET(listenfd, &rdset) )
{
if( (connfd=accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0)
{
printf("accept new client failure: %s\n", strerror(errno));
continue;
}
found = 0;
for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
{
if( fds_array[i] < 0 )
{
printf("accept new client[%d] and add it into array\n", connfd );
fds_array[i] = connfd;
found = 1;
break;
}
}
if( !found ){
printf("accept new client[%d] but full, so refuse it\n", connfd);
close(connfd);
}
}
else /* data arrive from already connected client */
{
for(i=0; i<ARRAY_SIZE(fds_array); i++)
{
if( fds_array[i]<0 || !FD_ISSET(fds_array[i], &rdset) )
continue;
if( (rv=read(fds_array[i], buf, sizeof(buf))) <= 0)
{
printf("socket[%d] read failure or get disconncet.\n", fds_array[i]);
close(fds_array[i]);
fds_array[i] = -1;
}
else
{
printf("socket[%d] read get %d bytes data\n", fds_array[i], rv);
/* convert letter from lowercase to uppercase */
for(j=0; j<rv; j++)
buf[j]=toupper(buf[j]);
if( write(fds_array[i], buf, rv) < 0 )
{
printf("socket[%d] write failure: %s\n", fds_array[i], strerror(errno));
close(fds_array[i]);
fds_array[i] = -1;
}
}
}
}
}
CleanUp:
close(listenfd);
return 0;
}
static inline void msleep(unsigned long ms)
{
struct timeval tv;
tv.tv_sec = ms/1000;
tv.tv_usec = (ms%1000)*1000;
select(0, NULL, NULL, NULL, &tv);
}
static inline void print_usage(char *progname)
{
printf("Usage: %s [OPTION]...\n", progname);
printf(" %s is a socket server program, which used to verify client and echo back string from it\n",
progname);
printf("\nMandatory arguments to long options are mandatory for short options too:\n");
printf(" -b[daemon ] set program running on background\n");
printf(" -p[port ] Socket server port address\n");
printf(" -h[help ] Display this help information\n");
printf("\nExample: %s -b -p 8900\n", progname);
return ;
}int socket_server_init(char *listen_ip, int listen_port)
{
struct sockaddr_in servaddr;
int rv = 0;
int on = 1;
int listenfd;
if ( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("Use socket() to create a TCP socket failure: %s\n", strerror(errno));
return -1;
}
/* Set socket port reuseable, fix 'Address already in use' bug when socket server restart */
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(listen_port);
if( !listen_ip ) /* Listen all the local IP address */
{
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
}
else /* listen the specified IP address */
{
if (inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0)
{
printf("inet_pton() set listen IP address failure.\n");
rv = -2;
goto CleanUp;
}
}
if(bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
{
printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
rv = -3;
goto CleanUp;
}
if(listen(listenfd, 13) < 0)
{
printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
rv = -4;
goto CleanUp;
}
CleanUp:
if(rv<0)
close(listenfd);
else
rv = listenfd;
return rv;
}三、poll多路复用
select()和poll()系统调用的本质一样，前者在BSD UNIX中引入的，后者在System V中引入的。poll()的机制与 select() 类
似，与 select() 在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是 poll() 没有最大文件
描述符数量的限制（但是数量过大后性能也是会下降）。poll() 和 select() 同样存在一个缺点就是，包含大量文件描述符的数组
被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增
大。
poll函数的原型：
#include <poll.h>
struct pollfd
{
int fd; /* 文件描述符 */
short events; /* 等待的事件 */
short revents; /* 实际发生了的事件 */
} ;
int poll(struct pollfd *fds, nfds_t nfds, int timeout);第一个参数用来指向一个struct pollfd类型的数组，每一个pollfd结构体指定了一个被监视的文件描述符，指示poll()监视多个文
件描述符。每个结构体的events域是监视该文件描述符的事件掩码，由用户来设置这个域。revents域是文件描述符的操作结果
事件掩码，内核在调用返回时设置这个域，events域中请求的任何事件都可能在revents域中返回。下表列出指定 events 标志以
及测试 revents 标志的一些常值：
第二个参数 nfds 指定数组中监听的元素个数；
第三个参数 timeout指定等待的毫秒数，无论I/O是否准备好，poll都会返回。timeout指定为负数值表示无限超时，使poll()
一直挂起直到一个指定事件发生；timeout为0指示poll调用立即返回并列出准备好I/O的文件描述符，但并不等待其它的事件。
这种情况下，poll()就像它的名字那样，一旦选举出来，立即返回。
使用poll()多路复用实现的服务器端示例部分代码：
* Parser the command line parameters */
while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
{switch (opt)
{
case 'b':
daemon_run=1;
break;
case 'p':
serv_port = atoi(optarg);
break;
case 'h': /* Get help information */
print_usage(progname);
return EXIT_SUCCESS;
default:
break;
}
}
if( !serv_port )
{
print_usage(progname);
return -1;
}
if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
{
printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
return -2;
}
printf("%s server start to listen on port %d\n", argv[0],serv_port);
/* set program running on background */
if( daemon_run )
{
daemon(0, 0);
}
for(i=0; i<ARRAY_SIZE(fds_array) ; i++)
{
fds_array[i].fd=-1;
}
fds_array[0].fd = listenfd;
fds_array[0].events = POLLIN;
max = 0;
for ( ; ; )
{
/* program will blocked here */
rv = poll(fds_array, max+1, -1);
if(rv < 0)
{
printf("select failure: %s\n", strerror(errno));
break;
}
else if(rv == 0)
{
printf("select get timeout\n");
continue;
}
/* listen socket get event means new client start connect now */
if (fds_array[0].revents & POLLIN)
{
if( (connfd=accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0)
{
printf("accept new client failure: %s\n", strerror(errno));
continue;}
found = 0;
for(i=1; i<ARRAY_SIZE(fds_array) ; i++)
{
if( fds_array[i].fd < 0 )
{
printf("accept new client[%d] and add it into array\n", connfd );
fds_array[i].fd = connfd;
fds_array[i].events = POLLIN;
found = 1;
break;
}
}
if( !found )
{
printf("accept new client[%d] but full, so refuse it\n", connfd);
close(connfd);
continue;
}
max = i>max ? i : max;
if (--rv <= 0)
continue;
}
else /* data arrive from already connected client */
{
for(i=1; i<ARRAY_SIZE(fds_array); i++)
{
if( fds_array[i].fd < 0 )
continue;
if( (rv=read(fds_array[i].fd, buf, sizeof(buf))) <= 0)
{
printf("socket[%d] read failure or get disconncet.\n", fds_array[i].fd);
close(fds_array[i].fd);
fds_array[i].fd = -1;
}
else
{
printf("socket[%d] read get %d bytes data\n", fds_array[i].fd, rv);
/* convert letter from lowercase to uppercase */
for(j=0; j<rv; j++)
buf[j]=toupper(buf[j]);
if( write(fds_array[i].fd, buf, rv) < 0 )
{
printf("socket[%d] write failure: %s\n", fds_array[i].fd, strerror(errno));
close(fds_array[i].fd);
fds_array[i].fd = -1;
}
}
}
}
}
......
int socket_server_init(char *listen_ip, int listen_port)
{
struct sockaddr_in servaddr;
int rv = 0;
int on = 1;
int listenfd;
if ( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("Use socket() to create a TCP socket failure: %s\n", strerror(errno));
return -1;
}
/* Set socket port reuseable, fix 'Address already in use' bug when socket server restart */
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(listen_port);
if( !listen_ip ) /* Listen all the local IP address */
{
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
}
else /* listen the specified IP address */
{
if (inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0)
{
printf("inet_pton() set listen IP address failure.\n");
rv = -2;
goto CleanUp;
}
}
if(bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
{
printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
rv = -3;
goto CleanUp;
}
if(listen(listenfd, 13) < 0)
{
printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
rv = -4;
goto CleanUp;
}
四、epoll多路复用
创建epoll实例：epoll_create()
#include <sys/epoll.h>
int epoll_create(int size);系统调用epoll_create()创建了一个新的epoll实例，其对应的兴趣列表初始化为空。若成功返回文件描述符，若出错返回-1。
参数size指定了我们想要通过epoll实例来检查的文件描述符个数。该参数并不是一个上限，而是告诉内核应该如何为内部数据结
构划分初始大小。从Linux2.6.8版以来，size参数被忽略不用。
作为函数返回值，epoll_create()返回了代表新创建的epoll实例的文件描述符。这个文件描述符在其他几个epoll系统调用中用
来表示epoll实例。当这个文件描述符不再需要时，应该通过close（）来关闭。当所有与epoll实例相关的文件描述符都被关闭
时，实例被销毁，相关的资源都返还给系统。从2.6.27版内核以来，Linux支持了一个新的系统调用epoll_create1()。该系统调用
执行的任务同epoll_create()一样，但是去掉了无用的参数size，并增加了一个可用来修改系统调用行为的flags参数。目前只支
持一个flag标志：EPOLL_CLOEXEC，它使得内核在新的文件描述符上启动了执行即关闭标志。
事件等待：epoll_wait()
参考博客：https://blog.csdn.net/huangjh2017/article/details/74611522
#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *evlist, int maxevents, int timeout); 第一个参数epfd是epoll_create()的返回值；
第二个参数evlist所指向的结构体数组中返回的是有关就绪态文件描述符的信息，数组evlist的空间由调用者负责申请；
第三个参数maxevents指定所evlist数组里包含的元素个数；
第四个参数timeout用来确定epoll_wait()的阻塞行为，有如下几种：
如果timeout等于-1，调用将一直阻塞，直到兴趣列表中的文件描述符上有事件产生或者直到捕获到一个信号为止。
如果timeout等于0，执行一次非阻塞式地检查，看兴趣列表中的描述符上产生了哪个事件。
如果timeout大于0，调用将阻塞至多timeout毫秒，直到文件描述符上有事件发生，或者直到捕获到一个信号为止。
数组evlist中，每个元素返回的都是单个就绪态文件描述符的信息。events字段返回了在该描述符上已经发生的事件掩码。
data字段返回的是我们在描述符上使用epoll_ctl()注册感兴趣的事件时在ev.data中所指定的值。注意，data字段是唯一可获知同
这个事件相关的文件描述符的途径。因此，当我们调用epoll_ctl()将文件描述符添加到感兴趣列表中时，应该要么将ev.date.fd设
为文件描述符号，要么将ev.date.ptr设为指向包含文件描述符号的结构体。
当我们调用epoll_ctl()时可以在ev.events中指定的位掩码以及由epoll_wait()返回的evlist[].events中的值如下所示：
使用epoll()多路复用实现的服务器端示例部分代码：
static inline void print_usage(char *progname);
int socket_server_init(char *listen_ip, int listen_port);
void set_socket_rlimit(void);
int main(int argc, char **argv)
{
int listenfd, connfd;
int serv_port = 0;
int daemon_run = 0;
char *progname = NULL;
int opt;
int rv;
int i, j;
int found;
char buf[1024];
int epollfd;
struct epoll_event event;
struct epoll_event event_array[MAX_EVENTS];
int events;
struct option long_options[] =
{
{"daemon", no_argument, NULL, 'b'},
{"port", required_argument, NULL, 'p'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
progname = basename(argv[0]);
/* Parser the command line parameters */
while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
{
switch (opt)
{
case 'b':
daemon_run=1;
break;
case 'p':
serv_port = atoi(optarg);
break;
case 'h': /* Get help information */
print_usage(progname);return EXIT_SUCCESS;
default:
break;
}
}
if( !serv_port )
{
print_usage(progname);
return -1;
}
set_socket_rlimit(); /* set max open socket count */
if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
{
printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
return -2;
}
printf("%s server start to listen on port %d\n", argv[0],serv_port);
/* set program running on background */
if( daemon_run )
{
daemon(0, 0);
}
if( (epollfd=epoll_create(MAX_EVENTS)) < 0 )
{
printf("epoll_create() failure: %s\n", strerror(errno));
return -3;
}
event.events = EPOLLIN|EPOLLET;
event.data.fd = listenfd;
if( epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event) < 0)
{
printf("epoll add listen socket failure: %s\n", strerror(errno));
return -4;
}
for ( ; ; )
{
/* program will blocked here */
events = epoll_wait(epollfd, event_array, MAX_EVENTS, -1);
if(events < 0)
{
printf("epoll failure: %s\n", strerror(errno));
break;
}
else if(events == 0)
{
printf("epoll get timeout\n");
continue;
}
/* rv>0 is the active events count */
for(i=0; i<events; i++)
{
if ( (event_array[i].events&EPOLLERR) || (event_array[i].events&EPOLLHUP) )
{
printf("epoll_wait get error on fd[%d]: %s\n", event_array[i].data.fd, strerror(errno));
epoll_ctl(epollfd, EPOLL_CTL_ADD, event_array[i].data.fd, &event);
close(event_array[i].data.fd);
}/* listen socket get event means new client start connect now */
if( event_array[i].data.fd == listenfd )
{
if( (connfd=accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0)
{
printf("accept new client failure: %s\n", strerror(errno));
continue;
}
event.data.fd = connfd;
event.events = EPOLLIN|EPOLLET;
if( epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event) < 0 )
{
printf("epoll add client socket failure: %s\n", strerror(errno));
close(event_array[i].data.fd);
continue;
}
printf("epoll add new client socket[%d] ok.\n", connfd);
}
else /* already connected client socket get data incoming */
{
if( (rv=read(event_array[i].data.fd, buf, sizeof(buf))) <= 0)
{
printf("socket[%d] read failure or get disconncet and will be removed.\n",
event_array[i].data.fd);
epoll_ctl(epollfd, EPOLL_CTL_ADD, event_array[i].data.fd, &event);
close(event_array[i].data.fd);
continue;
}
else
{
printf("socket[%d] read get %d bytes data\n", event_array[i].data.fd, rv);
/* convert letter from lowercase to uppercase */
for(j=0; j<rv; j++)
buf[j]=toupper(buf[j]);
if( write(event_array[i].data.fd, buf, rv) < 0 )
{
printf("socket[%d] write failure: %s\n", event_array[i].data.fd, strerror(errno));
epoll_ctl(epollfd, EPOLL_CTL_ADD, event_array[i].data.fd, &event);
close(event_array[i].data.fd);
}
}
}
} /* for(i=0; i<rv; i++) */
} /* while(1) */五、三种多路复用I/O的优缺点