c++ IO多路复用select/poll/epoll/et/lt相关api及代码实例

IO多路复用

简介

Linux系统中一切且为文件，每个文件用文件描述符(fd)来标识，可以对文件进行open/close/read/write等操作。但是这里存在一个问题，比如说调用read函数读取文件中的数据时，这个文件有可能为空(没有数据)，则有两种处理方式：

• 阻塞式IO：此时调用read函数的线程被挂起，直到文件非空，唤醒线程，则读取数据后正常返回。

优点：不占用CPU宝贵的时间片
缺点：同一时刻只能处理一个操作，效率低
当一个线程被阻塞了，显然不能响应其他操作，那么就需要再启动另一个线程来响应其他操作，所以有多线程编程的需求。

• 非阻塞式IO：立即返回，并标识错误状态。

优点：提高了程序的执行效率
缺点：需要占用更多的CPU和系统资源
阻塞式I/O的编程逻辑较非阻塞式的简单，不用考虑程序执行的状态。

在普通的socket通信中，服务器如果想要连接多个客户端需要使用多线程或多进程的方法，但这样会导致额外的资源开销，如线程的创建和销毁、线程的切换、因为线程并发问题而导致的上锁和解锁的消耗等。
故人们发明了IO多路复用技术（又称IO多路转接，下文称作IO多路复用）。

IO多路复用使得程序能够同时监听多个文件描述符，能够提高程序的性能，Linux下实现IO多路复用的系统调用主要有select、poll、epoll。

select

主旨思想

• 构造一个存放文件描述符的列表，将要监听的文件描述符放入列表中
• 调用系统函数监听该列表中的文件描述符，当该列表中一个或多个描述符进行io操作时，该函数才返回
  • 该函数是阻塞的
  • 函数对文件描述符检测的操作是由内核完成的
  • 函数的返回值是进行io操作的描述符的个数

相关api

#include <sys/time.h>
#include <sys/type.h>
#include <unistd.h>

// sizeof(fd_set) = 128B      ------     1024bit
int select(int nfds, fd_set* readfds, fs_set* writefds,\
              fd_set* exceptfds, struct timeval* timeout);
      - 参数：
            - nfds：委托内核监听的最大文件描述符的值 + 1 （因为是从０开始）
            - readfds：要检测的文件描述符的集合，委托内核检测它们的读操作，即检测读缓冲区；\
                       类型为指针，即传入传出参数\
                       将有数据传来的文件描述符的标志位置1，无数据的置0
            - writefds：要检测的文件描述符的集合，委托内核检测它们的写操作，即检测写缓冲区；\
                       类型为指针，即传入传出参数\
                       将还能写的文件描述符的标志位置1，已满的置0
            - exceptfds：检测异常，一般不用
            - timeout：超时时间
                       如果timeout = null，表示永久阻塞，直到有文件描述符状态变化
                       如果timeout.tv_sec = 0&&timeout.tv_usec = 0，表示不阻塞
       - 返回值： = -1， 表示失败； > 0，表示个数

// 将对应set中的文件描述符fd标志位置0
void FD_CLR(int fd, fd_set* set);

// 判断set中文件描述符fd的标注为是0还是1，为0返回0，为1返回1
int FD_ISSET(int fd, fd_set* set);

// 将文件描述符fd标志位设置为1
int FD_SET(int fd, fd_set* set);

// 将set中的文件描述符全部置0
int FD_ZERO(fd_set* set);

代码应用

// 创建socket
int lfd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in saddr;
saddrr.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 reads, tmpset;
FD_ZERO(&reads);
FD_SET(lfd, &rdset);

while(1){
    // 将reads传入，内核监听标志位为1的文件描述符，将其中没有事件发生的标志位置0，并返回个数
    // 内核会对集合进行修改，所以要传入备份集合
    tmpset = reads;
    int res = select(maxfd + 1, &tmpset, NULL, NULL, NULL);

    if(res == -1) perror("select");
    else if(res == 0) continue;     // 如果是不阻塞的情况，不可能为0
    else {
        // 新的客户端链接进来了
        if(FD_ISSET(lfd, &tmpset)){
            struct sockaddr_in cliaddr;
            int len = sizeof(cliaddr);
            int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);

            FD_SET(cfd, &reads);
			// update the maximize fd
            maxfd = maxfd > cfd? maxfd : cfd;
        }
        for(int i = lfd + 1; i <= maxfd; ++ i){
            if(FD_ISSET(i, &tmpset)){
            	// 说明这个文件描述符对应的客户端发来了数据
                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”);
					FD_CLR(i, &reads);
				}else{
					printf(“read buf = %s\n”, buf);
					write(i, buf, strlen(buf) + 1);
				}          
            }
        }
    }
}
close(lfd);

缺点

• 每次调用select，都需要把fd集合从用户态拷贝到内核态，当fd很多时，这个开销很大
• 每次调用select都需要在内核遍历传递进来的所有fd
• select支持的文件描述符数量太少了，默认1024
• fds集合不能重用，每次都要备份

poll

主旨思想

同select，将位图换成数组

api

#include <poll.h>
struct pollfd{
	int fd; 		// 委托内核检测的文件描述符
	short events;		// 委托内核检测什么事件
	short revents;		// 文件描述符实际发生什么事件
}

Int poll(struct pollfd* fds, nfds_t nfds, int timeout);
	- 参数：
		- fds：struct pollfd结构体数组，是需要检测的文件描述符集合
		- nfds：这是数组中最后一个有效元素的下表 + 1
		- timeout：阻塞时长。为0，不阻塞；-1，阻塞到有事件发生；大于0，阻塞的时长
	- 返回值：
		-1:失败
		大于0:表示有多少个事件发生

代码应用

// 创建socket
int lfd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in saddr;
saddrr.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 = 1;
while(1){
	int res = poll(fds, nfds + 1, -1);

    if(res == -1) perror("poll");
    else if(res == 0) continue;     // 如果是不阻塞的情况，不可能为0
    else {
        // 新的客户端链接进来了
        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;
				}
			}
			// update the maximize fd
            nfds = nfds > cfd? nfds : cfd;
        }
        for(int i = 1; i <= nfds; ++ i){
            if(fds[i].revents){
            	// 说明这个文件描述符对应的客户端发来了数据
                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{
					printf(“read buf = %s\n”, buf);
					write(i, buf, strlen(buf) + 1);
				}          
            }
        }
    }
}
close(lfd);

缺点

同select前两条

epoll

主旨思想

• 采用红黑树存储文件描述符，减少了遍历文件描述符带来的资源消耗
• 。。。。。。减少了内核态与用户态的相互转换带来的资源消耗

api

#include <says/poll.h>

// 创建一个新的epoll实例。在内核中创建了一个数据，这个数据有两个比较重要的数据：
   一是需要检测的文件描述符的信息（红黑树）
   二是存放事件发生的文件描述符信息的就绪列表（双向链表）

Int epoll_create(int size);
	- 参数：
		- size：discard。随便写一个正数
	- 返回值：
		为-1，失败；大于0，文件描述符

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
}
常见的epoll检测时事件：
	- EPOLLIN
	- EPOLLOUT
	- EPOLLERR

// 对epoll实例进行管理：添加文件描述符信息，删除信息，修改信息
int epol_ctl(int epfd, int op, int fd, struct epoll_event* event);
	- 参数：
		- epfd：epoll实例对应的文件描述符
		- op：要进行的操作（man epoll_ctl）
				 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，阻塞到事件发生；大于0，阻塞的时长
	- 返回值：
		- 成功：返回发生变化的文件描述符的个数
		- 失败：-1

代码应用

// 创建socket
int lfd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in saddr;
saddrr.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实例
int epfd = epoll_create(100);

// 将监听的文件描述符相关的监测信息添加到epoll实例中
struct epoll_event epev;
epev.events = EPOLLIN;
epev.data = 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{
            	// 说明这个文件描述符对应的客户端发来了数据
                char buf[1024] = {0};
      			 int len = read(cured, 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{
					printf(“read buf = %s\n”, buf);
					write(curfd, buf, strlen(buf) + 1);
				}          
		}
	}
}
close(lfd);
close(epfd);

工作模式

• LT模式（水平触发）

缺省的工作方式，并且同时支持block和no-block socket，在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果不做任何操作，内核还是会继续通知。

举例：读缓冲区有数据-> 检测fd的读缓冲区
- 用户不读书句，数据一直在缓冲区，epoll会一直通知
- 用户读了一部分数据，epoll会通知
- 缓冲区的数据读完了，不通知

• ET模式（边缘触发）

告诉工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变成就绪时，内核通过epoll告诉你，然后他会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多就绪通知，知道你做了某些操作导致那个文件描述符不再为就绪状态了。但是请注意，如果一直不对这个fd作IO操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once）。
ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞把处理多个文件描述符的任务饿死

举例：读缓冲区有数据-> epoll检测到了会给用户通知
- 用户不读数据，数据一直在缓冲区中，epoll下次检测的时候就不通知了
- 用户读了一部分数据，epoll不通知
- 缓冲区的数据读完了，不通知