《unix网络编程》（16）epoll函数

缺乏、安全感 2022-08-07 12:44 19阅读 0赞

# 几种模型的比较 #

关于PPC、TPC的问题、I/O复用的由来、epoll和select的详细对比参考文章：[高性能网络编程5--IO复用与并发编程][5--IO]

## 1 PPC、TPC模型    ##

传统的网络服务器是用**一个单独的线程或进程处理每一个连接**。对于高性能的应用，这需要在某一个时刻同时处理大量的客户请求，这种模式效率不高，因为(Process Per Connection,PPC), TPC(Thread Per Connection)模型一次处理许多客户连接，那么随着连接客户的增多，那么资源使用、进程/线程环境切换等的时空花销就会很大。

## 2 select 模型 ##

参看文章[《unix网络编程》（13)select、shutdown函数][unix_13_select_shutdown] [《unix网络编程》（15）poll函数以及使用poll的客户服务器程序][unix_15_poll_poll]  
1) 最大并发数限制，因为一个进程所打开的 FD （文件描述符）是有限制的，由 FD\_SETSIZE 设置，默认值是 1024，因此 Select 模型的最大并发数就被相应限制了。如果要改变FD\_SIZE的大小需要重新编译内核。

int select(int maxfdp1, fd_set *readfds, fd_set *writefds,  
               fd_set *exceptfds, struct timeval *timeout);

2)  效率问题， select 每次调用都会 **线性扫描**全部的 FD 集合，花费时间为O(n)，这样效率就会呈现线性下降，即使将 FD\_SETSIZE 改大其性能也会很差。  
3)  内核/用户空间内存拷贝问题， select 采取了**内存拷贝**方法让内核把 FD 消息通知给用户空间。

4）事件集，select的参数类型fd\_set没有将文件描述符和事件绑定，它仅仅是一个文件描述符的集合，因此select需要提供3个“**值-结果**”类型的参数分别传入和输出可读、可写和异常等事件（调用该函数时，指定所关心的描述符的值，函数返回时，结果将指示哪些描述符已经就绪），也就是select函数会修改指针readset、writeset、exceptset所指向的描述符集。

一方面，使得select不能处理更多类型的事件，所能处理的事件类型只有读写异常三类；

另一方面，描述符集内任何与未就绪描述符对应的位返回时都会被清空，因此每次重新调用select时，都需要再次把所有的描述符集内所关心的位置为1。

5）select函数的定时是有函数的最后一个参数决定的，它是一个timeval结构体，用于指定这段时间的秒数和微秒数。

//timeval结构:
    struct timeval
    {
        long    tv_sec;	    /* seconds */
        long	tv_usec;    /* microseconds */
    };

## 3 poll模型 ##

1）最大并发数限制，poll的第二个参数nfds是第一个参数指示的结构数据的元素个数，这个nfds并没有select的限制，它只受限于系统的内存空间（可以达到系统所允许打开的最大描述符的个数，即65535）。

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

2） 效率问题，效率和select类似。

3）内核/用户空间内存拷贝问题，和select类似。

4）事件集，poll比select要“聪明”，它将描述符和事件定义在一起，任何事件都被统一处理，编程接口简洁许多。

一方面，poll可以监听的事件类型就可以更细分为很多种（参考文章：[poll监听的事件类型][unix_15_poll_poll]）。

另一方面，而且内核每次修改的是pollfd结构体的revents成员，而events成员不变，因此下次重新调用poll无需重置pollfd类型中的事件集参数（避免了类似于select使用的的“值-结果”参数）。

5）poll的定时也是由函数的最后一个参数给出，但是它是一个int类型（指定函数要等待的毫秒数），而不是timeval结构体。

此外，从当今的可移植性角度考虑，**支持select的系统比支持poll的系统要多**。

# epoll的突破 #

## 优点    ##

**epoll是什么**？按照man手册的说法：**是为处理大批量句柄而作了改进的poll**。当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。

（1）epoll 没有最大并发连接的限制，上限是最大可以打开文件的数目，这个数字一般远大于 2048, 一般来说这个数目和系统内存关系很大 ，具体值可以 cat /proc/sys/fs/file-max\[599534\] 察看。

（2）效率提升， Epoll最大的优点就在于它**基于事件的就绪通知方式**：只管“活跃”的连接 ，而**跟连接总数无关**，其算法复杂度为O(1)，因此在实际的网络环境中，epoll的效率就会远远高于 select 和 poll 。select和poll都是轮询方式的，每次调用要扫描整个注册文件描述符集合，并将其中就绪描述符返回给用户程序。epoll\_wait采用的是回调方式，内核检测到就绪描述符时，将触发回调函数，回调函数就将该文件描述符上对应的事件插入内核就绪队列，不需要轮询。

（3）内存拷贝， Epoll 在这点上使用了“共享内存“，因此没有内存拷贝的开销。

epoll同样只告知那些就绪的文件描述符，而且当我们**调用epoll\_wait()获得就绪文件描述符**时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。  
另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才**对所有监视的文件描述符进行扫描**，而epoll事先通过epoll\_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll\_wait()时便得到通知。

5）和poll类似，epoll的定时也是int类型，单位是毫秒。

## 不足 ##

epoll的局限性在于它在Linux2.6才实现，而其他平台都没有，这与Apache这样的优秀跨平台服务器无法并论。select跨平台性能很好，几乎每个平台都支持。

![Center][]

# epoll函数及参数    #

int epoll_create(int size);
    int epoll_create1(int  flags);
    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); 
    int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

第一个函数：  
对于epoll\_create1 的flag参数: 可以设置为0 或EPOLL\_CLOEXEC，为0时函数表现与epoll\_create一致, EPOLL\_CLOEXEC标志与open 时的O\_CLOEXEC 标志类似，即进程被替换时会关闭打开的文件描述符。

创建一个epoll的句柄。自从linux2.6.8之后，size参数是被忽略的。需要注意的是，**当创建好epoll句柄后，它就是会占用一个fd值**，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以**在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽**。

第二个函数：

epoll的事件注册函数，它不同于select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。  
第一个参数是epoll\_create()的返回值。  
第二个参数表示动作，用三个宏来表示：  
EPOLL\_CTL\_ADD：注册新的fd到epfd中；EPOLL\_CTL\_MOD：修改已经注册的fd的监听事件；EPOLL\_CTL\_DEL：从epfd中删除一个fd；  
第三个参数是需要监听的fd。  
第四个参数是告诉内核需要监听什么事，struct epoll\_event结构如下：

struct epoll_event
    {
        uint32_t     events;      /* Epoll events */
        epoll_data_t data;        /* User data variable */
    };
    typedef union epoll_data
    {
        void        *ptr;
        int          fd;
        uint32_t     u32;
        uint64_t     u64;
    } epoll_data_t;

events可以是以下几个宏的集合：  
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；  
EPOLLOUT：表示对应的文件描述符可以写；  
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；  
EPOLLERR：表示对应的文件描述符发生错误；  
EPOLLHUP：表示对应的文件描述符被挂断；  
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。  
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里  
第三个函数：

收集在epoll监控的事件中已经发生的事件。参数events是分配好的epoll\_event结构体数组，epoll将会把发生的事件赋值到events数组中（events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在用户态中分配内存）。maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll\_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。如果函数调用成功，返回对应I/O上已准备好的文件描述符数目，如返回0表示已超时。

# epoll的两种工作模式 #

epoll有Level-Triggered和Edge-Triggered两种工作模式。

Level-Triggered是缺省工作方式，有阻塞和非阻塞两种方式。内核告诉你一个描述符是否就绪，然后可以对就绪的fd进行IO操作。如果不做任何操作，内核还会继续通知，因此该模式下编程出错可能性小。传统的select/poll是这样的模型。此方式可以认为是一个快速的poll。

Edge-Triggered是只支持非阻塞模式。当一个新的事件到达时，ET模式从epoll\_wait调用中获取该事件，如果这次没有将该事件对应的套接字缓冲区处理完，在这个套接字中没有新的事件再次到来时，在ET模式下是无法再次从epoll\_wait调用中获取这个事件的。而LT模式，只要一个事件对应的套接字缓冲区中还有数据，就总能从epoll\_wait中获取这个事件。

二者的差异在于 level-trigger 模式下只要某个 fd 处于 readable/writable 状态，**无论什么时候进行 epoll\_wait 都会返回该 fd**；而 edge-trigger 模式下只有某个 fd 从**unreadable 变为 readable 或从 unwritable 变为 writable 时，epoll\_wait 才会返回该 fd**。

以下黑体字来自[http://www.cppblog.com/peakflys/archive/2012/08/26/188344.aspx][http_www.cppblog.com_peakflys_archive_2012_08_26_188344.aspx]

使用LT意味着只要fd处于readable/writable状态，每次 epoll\_wait 时都会返回该 fd，系统开销不说，自己处理时每次都要把这些fd轮询一遍，如果fd很多的话，不管这些fd有没有事件发生，epoll\_wait 都会触发这些fd的轮询判断。  
查阅了一些资料，才知道常用的事件处理库很多都选择了 LT 模式，包括大家熟知的libevent和boost::asio等，为什么选择LT呢？那就不得不从ET的弊端的弊端说起。  
ET模式下，当有事件发生时，系统只会通知你一次，也就是调用epoll\_wait 返回fd后，不管事件你处理与否，或者处理完全与否，再调用epoll\_wait 时，都不会再返回该fd，这样programmer要自己保证在事件发生时及时有效的处理完。比如此时fd发生了EPOLLIN事件，在调用epoll\_wait 后发现此事件，programmer要保证在本次轮询中对此fd进行了读操作，并且还要循环调用recv操作，一直读到recv的返回值小于请求值，或者遇到EAGAIN错误，不然下次轮询时，如果此fd没有再次触发事件，你就没有机会知道这个fd需要你的处理。这样无形中就增加了programmer的负担和出错的机会。  
ET模式的短处正是LT模式的长处，无论此fd是否有事件发生，或者有事件未处理完，每次epoll\_wait 时总会得到此fd供你处理。显而易见，OS在LT模式下维护的 ready list 的大小肯定比ET模式下长，而且你自己轮询所有的fd时也要比ET下要多，这种消耗和ET模式下循环调用处理函数(如recv和send等)，还要逻辑处理是否处理完毕，理论上应该是LT更大一些，不过个人感觉应该差别不会太大。但是LT模式下带来的逻辑处理的方便性和不易出错性，让我们有理由把它作为首选。我想这可能也是为什么epoll后来在ET的基础上又增加了LT，并且将其作为默认模式的原因吧。

在epoll的ET模式下，正确的读写方式为：  
读：只要可读，就一直读，直到返回0，或者 errno = EAGAIN  
写：只要可写，就一直写，直到数据发送完，或者 errno = EAGAIN

例如，向socket中写数据：

![Center 1][]

从socket中读数据：

![Center 2][]

# epoll使用模型 #

epoll在ET模式下的使用，在下面代码段中，非阻塞模式下，函数do\_use\_fd函数新到达的文件描述符知道EAGAIN由read函数或write函数返回。

#define MAX_EVENTS 10
    struct epoll_event ev, events[MAX_EVENTS];
    int listen_sock, conn_sock, nfds, epollfd;
    
    /* Set up listening socket, 'listen_sock' (socket(),bind(), listen()) */
    epollfd = epoll_create(10);
    if (epollfd == -1) {
    	perror("epoll_create");
    	exit(EXIT_FAILURE);
    }
    
    ev.events = EPOLLIN;
    ev.data.fd = listen_sock;
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
    	perror("epoll_ctl: listen_sock");
    	exit(EXIT_FAILURE);
    }
    for (;;) {
    	nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
    	if (nfds == -1) {
    		perror("epoll_pwait");
    		exit(EXIT_FAILURE);
    	}
    	for (n = 0; n < nfds; ++n) {
    		if (events[n].data.fd == listen_sock) {
    			conn_sock = accept(listen_sock,
    				(struct sockaddr *) &local, &addrlen);
    			if (conn_sock == -1) {
    				perror("accept");
    				exit(EXIT_FAILURE);
    			}
    			setnonblocking(conn_sock);
    			ev.events = EPOLLIN | EPOLLET;
    			ev.data.fd = conn_sock;
    			if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {
    				perror("epoll_ctl: conn_sock");
    				exit(EXIT_FAILURE);
    			}
    		} else {
    			do_use_fd(events[n].data.fd);
    		}
    	}
    }

# epoll完整的服务器例子 #

客户端使用[《unix网络编程》（15）poll函数以及使用poll的客户服务器程序][unix_15_poll_poll]里的客户端。

服务器端代码(这里是[github上源码][github])：

//该版本使用epoll代替poll
    #include "myheader.h"
    #define OPEN_MAX 1024
    #define MAXEVENTS 64 
    
    //该函数是将套接字设置为非阻塞方式
    //使用的代码是fcntl开启非阻塞I/O的典型代码
    static int make_socket_non_blocking(int sfd) {
    	int flags;
    	if ((flags = fcntl(sfd, F_GETFL, 0)) == -1)
    		err_quit("fcntl F_GETEL error");
    	flags |= O_NONBLOCK;
    	if (fcntl(sfd, F_SETFL, flags) == -1)
    		err_quit("fcntl F_SETFL error");
    	return 0;
    }
    
    int main(int argc, char **argv)
    {
    	int i, maxi, listenfd, connfd, sockfd;
    	int nready;
    	ssize_t n;
    	char buf[MAXLINE];
    	socklen_t clilen;
    	struct epoll_event event, events[MAXEVENTS];
    
    	struct sockaddr_in cliaddr, servaddr;
    	listenfd = Socket(AF_INET, SOCK_STREAM, 0);
    	memset(&servaddr, 0, sizeof(servaddr));
    	servaddr.sin_family = AF_INET;
    	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    	servaddr.sin_port = htons(SERV_PORT);
    
    	// 在socket()和bind()之间设置套接字选项避免地址使用错误:
    	//结束服务器程序后“bind error: Address already in use” 
    	int opt = 1;
    	if ( setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1)
    		err_exit("setsockopt error\n");
    
    	Bind(listenfd, (const struct sockaddr*)&servaddr, sizeof(servaddr));
    
        //设置监听套接字为非阻塞模式
    	if (make_socket_non_blocking(listenfd) == -1) {
    		err_exit("make_socket_non_blocking error");
    	}
    	Listen(listenfd, LISTENQ);
    
    	//创建一个epoll的句柄，该句柄占用一个fd值，因此epoll使用完后要关闭
    	int efd = epoll_create1(EPOLL_CLOEXEC);
    	if (efd == -1)
    		err_exit("epoll_create1 error");
    	event.data.fd = listenfd;          //要监听的事件类型，这里监听listen套接字
    	event.events = EPOLLIN | EPOLLET;  //读入,边缘触发方式  
    	//epoll的事件注册函数，注册新的fd：listenfd到efd，并指明要监听的事件
    	int s = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &event);
    	if (s == -1)
    		err_quit("epoll_ctl error");
    
    	for( ; ; ) {
    		int i;
    		//收集监听到的消息，返回值nfds是已经准备好的描述符的个数
    		//下面的for循环只扫描已经准备好的描述符，这正是epoll比poll的高效之处
    		//定时器时间设置为-1表示一直等待知道有事件就绪
    		int nfds = epoll_wait(efd, events, MAXEVENTS, -1);
    		for (i = 0; i < nfds; i++) {
    			/* An error has occured on this fd, or the socket is not 
    			ready for reading (why were we notified then?) 
    			如果描述符发生错误、被挂断或者不是可读的描述符都关闭该描述符并继续
    			*/   
    			if ( (events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || 
    				(!(events[i].events & EPOLLIN))) {
    					fprintf(stderr, "epoll error\n");
    					close(events[i].data.fd);
    					continue;
    			}
    			/* We have a notification on the listening socket, which 
    			means one or more incoming connections. */   
    			else if (listenfd == events[i].data.fd) {
    				for ( ; ; ) {
    					struct sockaddr cliaddr;
    					char hbuf[MAXLINE], sbuf[MAXLINE];
    					socklen_t clilen = sizeof(cliaddr);
    					int connfd = accept(listenfd, (const struct sockaddr*)&cliaddr,
    						&clilen);
    					if (connfd == -1) {
    						//因为上边设置listenfd为非阻塞了，所以accept处理完listenfd后
    						//没有可以处理的套接字了，所以会返回EAGIN错误表示accept处理完了
    						//参考http://blog.csdn.net/u013074465/article/details/44993227
    						if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
    							break;
    						else { perror("accept DDDDDDD"); break;};
    
    					}
    					//将地址转化为主机名或者服务名 
    					//flag参数:以数字名返回主机地址和服务地址   
    					int s = getnameinfo(&cliaddr, clilen, hbuf, sizeof(hbuf),
    						sbuf, sizeof(sbuf), NI_NUMERICHOST
    						| NI_NUMERICSERV);
    					if (s == 0)  
    						printf("Accepted connection on descriptor %d "  
    						"(host=%s, port=%s)\n", connfd, hbuf, sbuf);  
    					/* Make the connection socket non-blocking and add it to the 
    					list of fds to monitor. */   		 
    					if (make_socket_non_blocking(connfd) == -1)
    						err_exit("make_socket_non_blocking connfd error");
    					event.data.fd = connfd;
    					event.events = EPOLLIN | EPOLLET;
    					if (epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &event) == -1)
    						err_exit("epoll_ctl error connfd");
    				}
    				continue;
    			}
    			else {
    				/* We have data on the fd waiting to be read. Read and 
    				display it. We must read whatever data is available 
    				completely, as we are running in edge-triggered mode 
    				and won't get a notification again for the same 
    				data. */   
    				int done = 0;
    				for ( ; ;) {
    					ssize_t count = read(events[i].data.fd, buf, sizeof(buf));
    					if (count == -1) {
    						/* If errno == EAGAIN, that means we have read all 
    						data. So go back to the main loop. */ 
    						if (errno != EAGAIN) {
    							printf("read...");
    							done = 1;
    						}
    						break;
    					}
    					else if (count == 0) {
    						/* End of file. The remote has closed the 
    						connection. */ 
    						done = 1;  
    						break;   
    					}
    
    					Write(STDOUT_FILENO, buf, count);  //write to stdout
    				}
    				if (done) {
    					printf("closed connection on descriptor %d\n", events[i].data.fd);
    					close(events[i].data.fd);
    				}
    			}
    		}
    	}
    	close(listenfd);
    	return EXIT_SUCCESS;
    }

# 程序运行截图及源码下载 #

启动服务器后，服务器分别接到了两个客户端的连接，客户端1连接并发送两条消息后客户退出；客户2发送一条消息后，服务器退出。

服务器：

![SouthEast][]

客户1：

![SouthEast 1][]

客户2：

![SouthEast 2][]

完整源码：[http://download.csdn.net/detail/u013074465/8583761][http_download.csdn.net_detail_u013074465_8583761]

[5--IO]: http://blog.csdn.net/russell_tao/article/details/17119729
[unix_13_select_shutdown]: http://blog.csdn.net/u013074465/article/details/44876955
[unix_15_poll_poll]: http://blog.csdn.net/u013074465/article/details/44901969
[Center]: /images/20220805/2e3819570c134dcf81ce2959c12121bd.png
[http_www.cppblog.com_peakflys_archive_2012_08_26_188344.aspx]: http://www.cppblog.com/peakflys/archive/2012/08/26/188344.aspx
[Center 1]: /images/20220805/b734702f1c5b4381a6bb6801c4335e08.png
[Center 2]: /images/20220805/a150293380d249fb9f10fffe0832e277.png
[github]: https://github.com/liyangddd/linux_practice/blob/master/network_programming/tcpsrvepoll.c
[SouthEast]: /images/20220805/6ca905c3001749149de3c30181ace625.png
[SouthEast 1]: /images/20220805/956407b7d8534dd1b720676b002c0a6d.png
[SouthEast 2]: /images/20220805/4c150cb3a6224cc68f857c29256c5765.png
[http_download.csdn.net_detail_u013074465_8583761]: http://download.csdn.net/detail/u013074465/8583761