IO复用之epoll模型

什么是epoll

epoll 是 Linux 操作系统提供的一种高性能的事件通知机制，用于处理大量文件描述符上的事件。它是一种 I/O 事件通知机制，通常用于处理网络编程中的并发连接。

在传统的 I/O 模型中，程序通常使用 select 或 poll 函数来等待多个文件描述符上的事件。这种方式有一些性能上的限制，特别是当需要监视的文件描述符数量很大时。epoll 的设计旨在解决这些性能问题。

以下是一些关键的 epoll 特性：

高性能： epoll 使用红黑树（RB tree）来存储文件描述符，这允许它在处理大量描述符时保持较低的时间复杂度，从而提高性能。

事件驱动： epoll 使用事件驱动的模型，即当文件描述符上有事件发生时，内核会通知应用程序。这避免了应用程序不断地轮询文件描述符，从而提高效率。

支持边缘触发和水平触发： epoll 可以以边缘触发（edge-triggered）或水平触发（level-triggered）的方式工作。边缘触发模式表示只有在文件描述符上的状态变化时才会通知应用程序，而水平触发模式表示只要文件描述符上有事件发生，就会通知应用程序。

支持单个系统调用处理多个事件： epoll 允许在一个系统调用中处理多个事件，这减少了系统调用的次数，提高了效率。

使用 epoll 可以更有效地管理大量并发连接，适用于服务器应用程序，特别是网络服务器，以提高性能和可伸缩性。在实际应用中，epoll 通常与非阻塞 I/O 配合使用，以更好地处理并发请求。

Epoll的三大函数：epoll_create，epoll_wait， epoll_ctl

epoll_create

#include<sys/epoll.h>
int epoll_create(int size);

成功时返回epoll文件描述符，失败时返回-1。

• size：epoll实例的大小。
• 该函数从2.3.2版本的开始加入的，2.6版开始引入内核
• Linux最新的内核稳定版本已经到了5.8.14，长期支持版本到了5.4.70
• 从2.6.8内核开始的Linux，会忽略这个参数，但是必须要大于0
• 这个是Linux独有的函数

epoll_ctl

#include<sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event);

成功时返回0，失败时返回-1。

• epfd 用于注册监视对象的epoll例程的文件描述符。
• op 用于指定监视对象的添加、删除或更改等操作。

EPOLL_CTL_ADD,EPOLL_CTL_MOD,EPOLL_CTL_DEL

• fd 需要注册的监视对象文件描述符。

event 监视对象的事件类型。

EPOLLIN∶需要读取数据的情况。

EPOLLOUT∶输出缓冲为空，可以立即发送数据的情况。

EPOLLPRI∶收到OOB数据的情况。

EPOLLRDHUP∶断开连接或半关闭的情况，这在边缘触发方式下非常有用。

EPOLLERR∶发生错误的情况。

EPOLLET∶以边缘触发的方式得到事件通知。

EPOLLONESHOT∶发生一次事件后，相应文件描述符不再收到事件通知。因此需要向

epoll_ctl函数的第二个参数传递

EPOLLCTL_MOD，再次设置事件

epoll_wait：

#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event*events,int maxevents,int timeout);

成功时返回发生事件的文件描述符数，失败时返回-1。

• epfd 表示事件发生监视范围的epol例程的文件描述符
• events 保存发生事件的文件描述符集合的结构体地址值。
• maxevents 第二个参数中可以保存的最大事件数目。
• Timeout：以1/1000秒为单位的等待时间，传递-1时，一直等待直到发生事件。

Epoll实战案例

基于eopll实现简单的文件上传下载功能，仅服务端代码

#include <cstdio>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include<pthread.h>
//#include<sys/types.h>
//#include<sys/stat.h>
#include <fcntl.h>
#include <sys/file.h>
#include <unordered_map>

#define EPOLL_EVENT_SIZE 100
#define USER_NUM 100

// 文件存放路径
const char* PATH = "/root/projects/chatdata/";

struct Data
{
	char typ;// 请求类型
	char content[1024]; // 请求内容
};
void error_handling(const char* msg) {
	fputs(msg, stderr);
	fputc('\n', stderr);
	exit(-1);
}

// 一个线程专门用来上传下载文件
void* thread_main(void* arg)
{
    //一个map管理文件描述符
	std::unordered_map<int, int> fdMap;
	pthread_detach(pthread_self());
	char filePath[1024];
	char buf[sizeof(Data)];
	memset(&buf, 0, sizeof(buf));
	// 准备套接字
	int serv_sock, clnt_sock;
	sockaddr_in serv_adr, clnt_adr;
	socklen_t client_sz;
	client_sz = sizeof(clnt_adr);
	serv_sock = socket(PF_INET, SOCK_STREAM, 0);
	serv_adr.sin_family = AF_INET;
	serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_adr.sin_port = htons(9091);

	if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1) {
		error_handling("bind() error");
		close(serv_sock);
		return 0;
	}
	if (listen(serv_sock, 5) == -1) {
		error_handling("listen() error");
		close(serv_sock);
		return 0;
	}
	epoll_event event;
	memset(&event, 0, sizeof(event));
	int epfd, event_cnt;
	epfd = epoll_create(1);
	if (epfd == -1) {
		error_handling("epoll_create() error");
		close(serv_sock);
		return 0;
	}
	epoll_event* all_events = new epoll_event[EPOLL_EVENT_SIZE];
	event.events = EPOLLIN;
	event.data.fd = serv_sock;
	epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);
	while (true) {
		event_cnt = epoll_wait(epfd, all_events, EPOLL_EVENT_SIZE, 1000);
		if (event_cnt == -1) {
			printf("epoll_wait() error");
			break;
		}
		if (event_cnt == 0)continue;
		for (int i = 0; i < event_cnt; i++) {
			// 监听可读事件
			if (all_events[i].events & EPOLLIN) {
				// 当发生的事件为服务器时接收接收连接
				if (all_events[i].data.fd == serv_sock) {
					clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &client_sz);
					// TODO  修改缓存区，娜迦算法
					if (clnt_sock == -1) {
						printf("accept() error");
						continue;
					}
					event.events = EPOLLIN;
					event.data.fd = clnt_sock;
					epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
				}
				else
				{
					ssize_t len = read(all_events[i].data.fd, buf, sizeof(buf));
					if (len <= 0) {
						// 取消监听，关闭文件操作符，关闭客户端sock
						epoll_ctl(epfd, EPOLL_CTL_DEL, all_events[i].data.fd, NULL);
						close(fdMap[all_events[i].data.fd]);
						close(all_events[i].data.fd);
						fdMap.erase(all_events[i].data.fd);
						printf("client is close! %d\n", clnt_sock);
					}
					else
					{
						if (buf[0] == 0) {
							//首次接收上传文件请求，打开文件
							memset(filePath, 0, sizeof(filePath));
							//const char* PATH = "/root/projects/chatdata/";
							strcpy(filePath, PATH);
							strcat(filePath, buf + 1);
							printf("filePath %s\n", filePath);
							int fd = open(filePath, O_WRONLY | O_CREAT | O_APPEND, 0777);
							perror("open");
							fdMap[all_events[i].data.fd] = fd;
						}
						else if (buf[0] == 1)
						{
							// 没有考虑文件终止问题EOF
							write(fdMap[all_events[i].data.fd], buf + 1, len - sizeof(buf[0]));
						}
						else if (buf[0] == 2)
						{
							// 用户请求下载文件
							memset(filePath, 0, sizeof(filePath));
							//const char* PATH = "/root/projects/chatdata/";
							strcpy(filePath, PATH);
							strcat(filePath, buf + 1);
							int fd = open(filePath, O_RDONLY);
							printf("filePath %s\n", filePath);
							printf("int fd = open(filePath, O_RDONLY); %d\n", fd);
							perror("open");
							unsigned long fileSize = static_cast<unsigned long>(lseek(fd, 0, SEEK_END));
							printf("unsigned long fileSize = static_cast<unsigned long>(lseek(fd, 0, SEEK_END)); %d\n", fileSize);
							lseek(fd, 0, SEEK_SET);
							memset(&buf, 0, sizeof(buf));
							memcpy(buf, &fileSize, sizeof(fileSize));
							//printf("memset(&buf, 0, sizeof(buf)); %d\n", buf);
							fdMap[all_events[i].data.fd] = fd;
							write(all_events[i].data.fd, buf, sizeof(buf));
							//修改监听的事件
							clnt_sock = all_events[i].data.fd;
						    event.events = EPOLLOUT;
							event.data.fd = clnt_sock;
							epoll_ctl(epfd, EPOLL_CTL_MOD, clnt_sock, &event);
						}
					}
				}
			}

			// 监听可写事件
			if (all_events[i].events & EPOLLOUT) {
				//开写
				int len = read(fdMap[all_events[i].data.fd], buf, sizeof(buf));
				write(all_events[i].data.fd, buf, len);
				if (len < sizeof(buf)) {
					// 写完了
					epoll_ctl(epfd, EPOLL_CTL_DEL, all_events[i].data.fd, NULL);
					close(fdMap[all_events[i].data.fd]);
					close(all_events[i].data.fd);
					fdMap.erase(all_events[i].data.fd);
					printf("client is close! %d\n", clnt_sock);
				}
			}
		}
	}

	delete all_events;
	close(serv_sock);


	pthread_exit(0);
}

int main()
{

	pthread_t t_id;
	int thread_param = 5;
	//thread_param表示函数传参 ， thread_main表示线程函数
	if (pthread_create(&t_id, NULL, thread_main, (void*)&thread_param) != 0)
	{
		puts("pthread_create() error");
		return -1;
	};
	// TODO 其他的业务逻辑
	return 0;
}