【C语言】Linux Socket epoll多路复用

---

前言

前面谈完 poll 多路复用，这篇文章我们来聊聊 epoll 多路复用

在 Linux 没有实现 epoll 事件驱动机制之前，我们一般选择用 select 或者 poll 等 IO 多路复用的方法来实现并发服务程序。自 Linux 2.6 内核正式引入 epoll 以来，epoll 已经成为了目前实现高性能网络服务器的必备技术，在大数据、高并发、集群等一些名词唱得火热之年代，select 和 poll 的用武之地越来越有限，风头已经被 epoll 占尽。

select的缺点：

1. 单个进程能够监视的文件描述符的数量存在最大限制，通常是1024，当然可以更改数量，但由于select采用轮询的方式扫描文件描述符，文件描述符数量越多，性能越差；
2. 内核 / 用户空间内存拷贝问题，select需要复制大量的句柄数据结构，产生巨大的开销；
3. select返回的是含有整个句柄的数组，应用程序需要遍历整个数组才能发现哪些句柄发生了事件；
4. select的触发方式是水平触发，应用程序如果没有完成对一个已经就绪的文件描述符进行IO操作，那么之后每次select调用还是会将这些文件描述符通知进程。
   相比select模型，poll使用链表保存文件描述符，因此没有了监视文件数量的限制，但其他三个缺点依然存在。拿select模型为例，假设我们的服务器需要支持100万的并发连接，则在__FD_SETSIZE
   为1024的情况下，则我们至少需要开辟1k个进程才能实现100万的并发连接。除了进程间上下文切换的时间消耗外，从内核/用户空间大量的无脑内存拷贝、数组轮询等，是系统难以承受的。因此，基于select模型的服务器程序，要达到10万级别的并发访问，是一个很难完成的任务。

---

一、epoll 多路复用是什么？

• epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。epoll除了提供select/poll那种IO事件的水平触发（Level Triggered）外，还提供了边缘触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。

• LT（level triggered）是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。

• ET （edge-triggered）是高速工作方式，只支持non-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了（比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once），不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。

• ET和LT的区别就在这里体现，LT事件不会丢弃，而是只要读buffer里面有数据可以让用户读，则不断的通知你。而ET则只在事件发生之时通知。可以简单理解为LT是水平触发，而ET则为边缘触发。LT模式只要有事件未处理就会触发，而ET则只在高低电平变换时（即状态从1到0或者0到1）触发。

• 由于epoll的实现机制与select/poll机制完全不同，上面所说的 select的缺点在epoll上不复存在。设想一下如下场景：有100万个客户端同时与一个服务器进程保持着TCP连接。而每一时刻，通常只有几百上千个TCP连接是活跃的(事实上大部分场景都是这种情况)。如何实现这样的高并发？在select/poll时代，服务器进程每次都把这100万个连接告诉操作系统(从用户态复制句柄数据结构到内核态)，让操作系统内核去查询这些套接字上是否有事件发生，轮询完后，再将句柄数据复制到用户态，让服务器应用程序轮询处理已发生的网络事件，这一过程资源消耗较大，因此，select/poll一般只能处理几千的并发连接。

• epoll的设计和实现与select完全不同。epoll通过在Linux内核中申请一个简易的文件系统，把原先的select/poll调用分成了3个部分：

  1. 调用epoll_create()建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)
  2. 调用epoll_ctl向epoll对象中添加这100万个连接的套接字
  3. 调用epoll_wait收集发生的事件的连接

• 如此一来，要实现上面说是的场景，只需要在进程启动时建立一个epoll对象，然后在需要的时候向这个epoll对象中添加或者删除连接。同时，epoll_wait的效率也非常高，因为调用epoll_wait时，并没有一股脑的向操作系统复制这100万个连接的句柄数据，内核也不需要去遍历全部的连接。

二、epoll 函数解析

1、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，它使得内核在新的文件描述符上启动了执行即关闭标志。

2、epoll_ctl() 函数

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

• 系统调用 epoll_ctl() 能够修改由文件描述符 epfd 所代表的 epoll 实例中的兴趣列表。若成功返回0，若出错返回-1。
• 参数1（int epfd）： 是 epoll_create() 的返回值
• 参数2（int op）： 用来指定需要执行的操作
  • EPOLL_CTL_ADD： 将描述符 fd 添加到 epoll 实例中的兴趣列表中去。对于 fd 上我们感兴趣的事件，都指定在 event 所指向的结构体中。如果我们试图向兴趣列表中添加一个已存在的文件描述符，epoll_ctl()将出现EEXIST错误；
  • EPOLL_CTL_MOD： 修改描述符上设定的事件，需要用到由 event 所指向的结构体中的信息。如果我们试图修改不在兴趣列表中的文件描述符， epoll_ctl() 将出现ENOENT错误；
  • EPOLL_CTL_DEL： 将文件描述符 fd 从 epfd 的兴趣列表中移除，该操作忽略参数 event。如果我们试图移除一个不在 epfd 的兴趣列表中的文件描述符，epoll_ctl() 将出现ENOENT错误。关闭一个文件描述符会自动将其从所有的 epoll 实例的兴趣列表移除；
• 参数3（int fd）： 指明了要修改兴趣列表中的哪一个文件描述符的设定。该参数可以是代表管道、FIFO、套接字、POSIX 消息队列、inotify 实例、终端、设备，甚至是另一个 epoll 实例的文件描述符。但是，这里 fd 不能作为普通文件或目录的文件描述符；
• 参数4（struct epoll_event *event）： 是一个指向结构体 epoll_event 的指针。参数 event 为文件描述符 fd 所做的设置（epoll_event）如下：
  • events 字段是一个位掩码，它指定了我们为待检查的描述符 fd 上所感兴趣的事件集合；
  • data 字段是一个联合体，当描述符 fd 稍后称为就绪态时，联合的成员可用来指定传回给调用进程的信息；

typedef union epoll_data
{
	void		*ptr;	/* Pointer to user-defind data */
	int			 fd;	/* File descriptor */
	uint32_t	 u32;	/* 32-bit integer */
	uint64_t	 u64;	/* 64-bit integer */
} epoll_data_t;

struct epoll_event
{
	uint32_t events;	/* epoll events(bit mask) */
	epoll_data_t data;	/* User data */
};

3、epoll_wait() 函数

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

• 系统调用 epoll_wait() 返回 epoll 实例中处于就绪态的文件描述符信息，单个 epoll_wait() 调用能够返回多个就绪态文件描述符的信息。调用成功后 epoll_wait() 返回值是数组 evlist 中的元素个数
  • 如果在 timeout 超时间隔内没有任何文件描述符处于就绪态的话就返回 0
  • 出错时返回 -1 并在 errno 中设定错误码以表示错误原因。
• 参数1（int epfd）： 是epoll_create()的返回值；
• 参数2（struct epoll_event *evlist）： evlist所指向的结构体数组中返回的是有关就绪态文件描述符的信息，数组evlist的空间由调用者负责申请；
• 参数3（int maxevents）： maxevents指定所evlist数组里包含的元素个数；
• 参数4（int 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() 时可以在 event.events 中指定的位掩码以及由 epoll_wait() 返回的 evlist[].events 中的值如下所示：

默认情况下，一旦通过 epoll_ctl() 的 EPOLL_CTL_ADD 操作将文件描述符添加到 epoll 实例的兴趣列表中后，它会保持激活状态（即，之后对 epoll_wait() 的调用会在描述符处于就绪态时通知我们）直到我们显示地通过 epoll_ctl() 的 EPOLL_CTL_DEL 操作将其从列表中移除。如果我们希望在某个特定的文件描述符上只得到一次通知，那么可以在传给 epoll_ctl() 的 event.events 中指定 EPOLLONESHOT 标志。如果指定了这个标志，那么在下一个 epoll_wait() 调用通知我们对应的文件描述符处于就绪态之后，这个描述符就会在兴趣列表中被标记为非激活态，之后的 epoll_wait() 调用都不会再通知我们有关这个描述符的状态了。如果需要，我们可以稍后用过调用 epoll_ctl() 的 EPOLL_CTL_MOD 操作重新激活对这个文件描述符的检查

三、具体代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <sys/time.h>
#include <sys/resource.h>

/* 定义socket可排队个数 */
#define BACKLOG			128
/* 此宏用来计算数组的元素个数 */
#define ARRAY_SIZE(x) 	(sizeof(x)/sizeof(x[0]))
/* 用来定义event_array数组的元素个数 */
#define MAX_EVENTS		512

int socket_server_init(char *listen_ip, int listen_port);
void set_socket_rlimit(void);

int main(int argc, char **argv)
{
	int					listen_fd = -1; 
	int					client_fd = -1;
	int					rv = -1;
	int					listen_port = 0;
	int					i, j;
	int					found;
	char				buf[1024];
	int					epoll_fd;
	struct epoll_event	event;
	struct epoll_event	event_array[MAX_EVENTS];
	int					events;
	
	/* 用来确认程序执行的格式是否正确，不正确则退出并提醒用户 */
	if (argc < 2)
	{
		printf("Program usage: %s [Port]\n", argv[0]);
		return -1;
	}
	
	//将端口参数赋给参数变量
	//由于命令行传参进来是字符串类型，所以需要atoi转换为整型
	listen_port = atoi(argv[1]);
	
	/* 封装了一个函数来设置资源限制 */
	set_socket_rlimit();

	/* 创建listen_fd，这里封装了一个函数 */
	if ((listen_fd = socket_server_init(NULL, listen_port)) < 0)
	{
		printf("server listen on port[%d] failure: %s\n", listen_port, strerror(errno));
		return -2;
	}
	
	/* 创建一个epoll实例 */
	if ((epoll_fd = epoll_create(MAX_EVENTS)) < 0)
	{
		printf("epoll_create epoll_fd failure: %s\n", strerror(errno));
		goto cleanup;
	}
	printf("epoll_create epoll_fd[%d]\n", epoll_fd);
	
	/* 把listen_fd和期盼的事件EPOLLIN添加到结构体中 */
	event.events = EPOLLIN;	
	event.data.fd = listen_fd;
	
	/* 将listen_fd添加到epoll实例中的兴趣列表中去 */
	if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &event))
	{
		printf("ADD listen_fd to epoll failure: %s\n", strerror(errno));
		goto clean;
	}

	while (1)
	{
		
		/* 
		 * 通过epoll_wait()返回epoll实例中处于就绪态的文件描述符的个数
		 * 并把有关就绪态文件描述符的信息，存入event_array数组中
		 * 所以能保证，event_array数组中的元素均是实际有事件发生的
		 * 返回0：说明在超时前没有任何事件发生；
		 * 返回-1：说明失败
		 */
		if ((events = epoll_wait(epoll_fd, event_array, MAX_EVENTS, -1)) < 0)
		{
			printf("epoll_wait() failure: %s\n", strerror(errno));
			break;
		}
		else if (events == 0)
		{
			printf("epoll_wait() timeout\n");
			continue;
		}
		

		/* 有消息来了，对发生的事件逐件逐件解决 */
		for (i=0; i<events; i++)
		{
			/* 如果实际发生的事件为出错或挂断，则关闭与该客户端的连接 */
			if ((event_array[i].events & EPOLLERR) || (event_array[i].events & EPOLLHUP))
			{
				printf("client[%d] error or get disconnected\n", event_array[i].data.fd);
				epoll_ctl(epoll_fd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
				close(event_array[i].data.fd);
				continue;
			}
			
			/* 判断是不是listen_fd的消息 */
			if (event_array[i].data.fd == listen_fd)
			{
				/*
				 * accept()
				 * 接受来自客户端的连接请求
				 * 返回一个client_fd与客户通信
				 */
				printf("\n");
				if ((client_fd = accept(listen_fd, (struct sockaddr *)NULL, NULL)) < 0)
				{
					printf("accept new client failure: %s\n", strerror(errno));
					continue;
				}
				
				/* 把client_fd和期盼的事件EPOLLIN添加到结构体中 */
				event.events = EPOLLIN;
				event.data.fd = client_fd;
				
				/* 将client_fd添加到epoll实例中的兴趣列表中去 */
				if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event) < 0)
				{
					printf("epoll_ctl() client_fd failure: %s\n", strerror(errno));
					close(client_fd);
					continue;
				}
				printf("accept new client[%d] and add it to epoll\n", client_fd);

			}
			else	/* 来自已连接客户端的消息 */
			{	
				/*
				 * 能进入到else这里
				 * 就已经能百分百保证该fd是一个与客户端进行通信的fd
				 * 并且有事件发生
				 * 所以直接进行读操作即可
				 */
				memset(buf, 0, sizeof(buf));
				
				/* 
				 * 若读失败或连接断开
				 * 则将该fd从epoll兴趣列表中删除
				 * 并关掉该 fd
				 */
				if ((rv = read(event_array[i].data.fd, buf, sizeof(buf))) <= 0)
				{
					printf("read data from client[%d] failure or get disconnected, close it\n", event_array[i].data.fd);
					epoll_ctl(epoll_fd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
					close(event_array[i].data.fd);
					continue;
				}
				printf("read %d Bytes data from client[%d]: %s\n", rv, event_array[i].data.fd, buf);

				for (j=0; j<rv; j++)
				{
					if (buf[j] >= 'a' && buf[i] <= 'z')
						buf[j] = toupper(buf[j]);
				}
				
				/* 
				 * 若写数据失败
				 * 则将该fd从epoll兴趣列表中删除
				 * 并关掉该 fd
				 */
				if ((rv = write(event_array[i].data.fd, buf, rv)) < 0)
				{
					printf("write data to client[%d] failure: %s\n", event_array[i].data.fd, strerror(errno));
					epoll_ctl(epoll_fd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
					close(event_array[i].data.fd);
					continue;
				}
				printf("write %d Bytes data to client[%d]: %s\n", rv, event_array[i].data.fd, buf);

			} /* end of client_message */

		} /* end of for(i=0; i<events; i++) */

	} /* while(1) */
clean:
	close(epoll_fd);

cleanup:
	close(listen_fd);
	return 0;

} /* end of main() function */

/*
 * Socket Server Init Function
 * 创建 listen_fd，bind绑定ip和端口，并监听
 */
int socket_server_init(char *listen_ip, int listen_port)
{	
	int					rv = 0;
	int					listen_fd = -1;
	struct sockaddr_in	servaddr;
	int					on = 1;
	
	/*
	 * socket()，创建一个新的sockfd
	 * 指定协议族为IPv4
	 * socket类型为SOCK_STREAM（TCP）
	 */
	if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{		
		printf("create listen_fd failure: %s\n", strerror(errno));
		return -1;
	}
	printf("create listen_fd[%d] success\n", listen_fd);

	//设置套接字端口可重用，修复了当Socket服务器重启时“地址已在使用(Address already in use)”的错误
	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

	/*
	 * bind()，将服务器的协议地址绑定到listen_fd
	 */
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(listen_port);
	if (!listen_ip)	//如果ip为空，则监听本机所有ip
	{
		servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	}
	else
	{
		/* 将点分十进制的ip地址转为32位整型传入结构体 */
		if (inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0)
		{
			printf("inet_pton set listen_ip address failure: %s\n", strerror(errno));
			rv = -2;
			goto cleanup;
		}
	}

	if (bind(listen_fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
	{
		printf("bind listen_fd[%d] failure: %s\n", listen_fd, strerror(errno));
		rv = -3;
		goto cleanup;
	}

	/*
	 * listen()
	 * 监听listen_fd的端口，并设置最大排队连接个数
	 */
	if (listen(listen_fd, BACKLOG) < 0)
	{
		printf("listen listen_fd on listen_port[%d] failure: %s\n", listen_port, strerror(errno));
		rv = -4;
		goto cleanup;
	}

cleanup:
	if (rv < 0)
		close(listen_fd);
	else
		rv = listen_fd;

	return rv;
}

/*
 * 修改资源限制
 */
void set_socket_rlimit(void)
{
	struct rlimit limit = {0};
	/* 获取进程能打开的最多文件描述符个数，存到limit结构体中 */
	if (getrlimit(RLIMIT_NOFILE, &limit) < 0)
	{
		printf("getrlimit() failure: %s\n", strerror(errno));
	}
	/* 把软件资源限制修改为硬件资源限制大小 */
	limit.rlim_cur = limit.rlim_max;
	/* 设置进程能打开的最多文件描述符个数 */
	if (setrlimit(RLIMIT_NOFILE, &limit) < 0)
	{
		printf("setrlimit() failure: %s\n", strerror(errno));
	}
	printf("set socket open fd max count to  %d\n", limit.rlim_cur);
}

四、运行效果

---

总结

以上是对Linux epoll多路复用的一些理解，如有写的不好的地方，还请各位大佬不吝赐教。