多路复用之epoll（）

自从epoll被引进以来，epoll已经成为了目前实现高性能网络服务器的必备技术，在大数据，高并发，集群等一些名词唱得火热之年代，select和poll的用武之地越来越有限，风头已经被epoll占尽。
相比select模型，poll使用链表保存文件描述符，因此没有了监视文件数量的限制。拿select模型为例，假设我们的服务器需要支持100万的并发连接，则在_FD_SETSIZE为1024的情况下，则我们至少要开辟1k个进程才能实现100万的并发连接。除了进程上下文切换的时间消耗外，从内核/用户空间的无脑内存拷贝，数组轮询等，是系统难以承受的。因此，基于select模型的服务器，很难完成10万级别的并发访问。
epoll是linux内核为处理大批量文件描述符而作了改进的poll，是linux下多路复用select/poll的增强版本，它能显著的提高程序在大量的并发连接中只有少量活跃的情况下的系统CPU利用率。另一个原因就是获取事件的时候，它无需遍历整个被监听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入ready队列的描述符集合就行了。epoll除了提供select/poll那种水平触发，还提供了边缘触发，这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序的效率。
**LT（水平触发）：**是缺省的工作方式，并且同时支持block和no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不进行任何操作，内核还是会继续通知你，所以，这种模式编程出错误可能要小一点。传统的的select/poll都是这种模型的代表。
**ET（边缘触发）：**是高速的工作方式。只支持non-block socket。在这种模式下，当描述符从未就绪变成就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了，内核不会发送更多的通知，不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确定。
LT和ET的区别就在这里体现，LT事件不会丢弃触发，而是只要读buff里面有数据可以让用户读，则不断的通知你。而ET则只是在事件发生之时通知。LT模式只要有事件未处理就会触发，而ET则为边缘触发。LT模式只要有事件未处理就要触发，而ET则只在高低电平变换时（状态从1到0或者0到1）触发。

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

1调用epoll_creat()简历一个epoll对象（在epoll文件系统中为这个句柄对象分配资源）
2调用epoll_ctl向epoll对象中添加这100万个连接的套接字
3调用epoll_wait收集发生的时间

创建epoll epoll_create()

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

系统调用epoll_creat（）创建了一个新的epoll实例，其对应的兴趣列表初始化为空，若成功返回文件描述符，若出错返回-1.参数size指定了我们想要通过epoll实例来检查文件的描述符个数。该参数并不是一个上限，而是告诉内核如何为内部数据结构划分初始大小。
修改epoll的兴趣列表： epoll_ctl()

在这里插入代码片#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);

系统调用epoll_ctl()能够修改由文件描述符epfd所代表的epoll实例中的兴趣列表。若成功返回0，若出错返回-1。
第一个参数epfd 是epoll_create()的返回值；
第二个参数op用来指定需要执行的操作，它可以是如下几种值：
EPOLL_CTL_ADD：将描述符fd添加到epoll实例中的兴趣列表中去。对于fd上我们感兴趣的事件，都指定在ev所指向的结构体中。如果我们试图向兴趣列表中添加一个已存在的文件描述符，epoll_ctl()将出现EEXIST错误

EPOLL_CTL_MOD：修改描述符上设定的事件，需要用到由ev所指向的结构体中的信息。如果我们试图修改不在兴趣列表中的文件描述符，epoll_ctl()将出现ENOENT错误；

EPOLL_CTL_DEL：将文件描述符fd从epfd的兴趣列表中移除，该操作忽略参数ev。如果我们试图移除一个不在epfd的兴趣列表中的文件描述符，epoll_ctl()将出现ENOENT错误。关闭一个文件描述符会自动将其从所有的epoll实例的兴趣列表移除；
第三个参数fd指明了要修改兴趣列表中的哪一个文件描述符的设定。该参数可以是代表管道、FIFO、套接字、POSIX消息队
列、inotify实例、终端、设备，甚至是另一个epoll实例的文件描述符。但是，这里fd不能作为普通文件或目录的文件描述符；
第四个参数ev是指向结构体epoll_event的指针，结构体的定义如下：

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 */
};

参数ev为文件描述符fd所做的设置（epoll_event）如下：

events字段是一个位掩码，它指定了我们为待检查的描述符fd上所感兴趣的事件集合；
data字段是一个联合体，当描述符fd稍后称为就绪态时，联合的成员可用来指定传回给调用进程的信息；
事件等待： 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中设定错误码以表示错误原因。
第一个参数epfd是epoll_create()的返回值；
第二个参数evlist所指向的结构体数组中返回的是有关就绪态文件描述符的信息，数组evlist的空间由调用者负责申请；
第三个参数maxevents指定所evlist数组里包含的元素个数；
第四个参数timeout用来确定epoll_wait()的阻塞行为，有如下几种：
如果timeout等于-1，调用将一直阻塞，直到兴趣列表中的文件描述符上有事件产生或者直到捕获到一个信号为止。
如果timeout等于0，执行一次非阻塞式地检查，看兴趣列表中的描述符上产生了哪个事件。
如果timeout大于0，调用将阻塞至多timeout毫秒，直到文件描述符上有事件发生，或者直到捕获到一个信号为止。
下面是使用epoll（）多路复用实现的服务器端示例代码：

#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>
#include <sys/epoll.h>
#include <sys/resource.h>
#define MAX_EVENTS 512
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
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 failuren", argv[0],serv_port);
		 return -2;
	 }
	 printf("%s server start to listen on port %dn", 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: %sn", strerror(errno));
		 return -3;
	 }
	 //event.events = EPOLLIN|EPOLLET;
	 event.events = EPOLLIN;
	 event.data.fd = listenfd;
	 if( epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event) < 0)
	 {
		 printf("epoll add listen socket failure: %sn", strerror(errno));
		 return -4;
	 }
 for ( ; ; )
 {
	 /* program will blocked here */
	 events = epoll_wait(epollfd, event_array, MAX_EVENTS, -1);
	 if(events < 0)
	 {
		 printf("epoll failure: %sn", strerror(errno));
		 break;
	 }
	 else if(events == 0)
	 {
	 printf("epoll get timeoutn");
	 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]: %sn", event_array[i].data.fd, 	strerror(errno));
			 epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
			 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: %sn", strerror(errno));
				 continue;
			 }
			 event.data.fd = connfd;
			 //event.events = EPOLLIN|EPOLLET;
			 event.events = EPOLLIN;
			 if( epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event) < 0 )
			 {
				 printf("epoll add client socket failure: %sn", 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_DEL, event_array[i].data.fd, NULL);
			 close(event_array[i].data.fd);
			 continue;
		 }
		 else
		 {
			 printf("socket[%d] read get %d bytes datan", 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: %sn", event_array[i].data.fd, strerror(errno));
				 epoll_ctl(epollfd, EPOLL_CTL_DEL, event_array[i].data.fd, NULL);
				 close(event_array[i].data.fd);
			 }
		 }
	 }
 } /* for(i=0; i<rv; i++) */
  } /* while(1) */
CleanUp:
	 close(listenfd);
	 return 0;
}
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 itn",
	progname);
	 printf("nMandatory arguments to long options are mandatory for short options too:n");
	 printf(" -b[daemon ] set program running on backgroundn");
	 printf(" -p[port ] Socket server port addressn");
	 printf(" -h[help ] Display this help informationn");
	 printf("nExample: %s -b -p 8900n", 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: %sn", 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: %sn", strerror(errno));
	 rv = -3;
	 goto CleanUp;
	 }
	 if(listen(listenfd, 64) < 0)
	 {
	 printf("Use bind() to bind the TCP socket failure: %sn", strerror(errno));
	 rv = -4;
	 goto CleanUp;
	 }
CleanUp:
	 if(rv<0)
	 close(listenfd);
	 else
	 rv = listenfd;
	 return rv;
}
/* Set open file description count to max */
void set_socket_rlimit(void)
{
	 struct rlimit limit = {0};
	 getrlimit(RLIMIT_NOFILE, &limit );
	 limit.rlim_cur = limit.rlim_max;
	 setrlimit(RLIMIT_NOFILE, &limit );
	 printf("set socket open fd max count to %dn", limit.rlim_max);
}

最后

以上就是虚拟航空最近收集整理的关于多路复用之epoll（）的全部内容，更多相关多路复用之epoll（）内容请搜索靠谱客的其他文章。