Socket套接字编程（I/O复用 epoll）

epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。

目前epell是linux大规模并发网络程序中的热门首选模型。epoll除了提供select/poll那种IO事件的电平触发（Level Triggered）外，还提供了边沿触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。

可以使用cat命令查看一个进程可以打开的socket描述符上限。cat /proc/sys/fs/file-max；有需要的话，可以通过修改配置文件的方式修改该上限值。

API简介

1. 创建一个epoll句柄，参数size用来告诉内核监听的文件描述符的个数，跟内存大小有关。

   #include 
   int epoll_create(int size)		size：监听数目
   

    

2. 控制某个epoll监控的文件描述符上的事件：注册、修改、删除。

   #include 
   	int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
   		epfd：	为epoll_creat的句柄
   		op：		表示动作，用3个宏来表示：
   			EPOLL_CTL_ADD (注册新的fd到epfd)，
   			EPOLL_CTL_MOD (修改已经注册的fd的监听事件)，
   			EPOLL_CTL_DEL (从epfd删除一个fd)；
   		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;
   		EPOLLIN ：	表示对应的文件描述符可以读（包括对端SOCKET正常关闭）
   		EPOLLOUT：	表示对应的文件描述符可以写
   		EPOLLPRI：	表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）
   		EPOLLERR：	表示对应的文件描述符发生错误
   		EPOLLHUP：	表示对应的文件描述符被挂断；
   		EPOLLET： 	将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的
   		EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
   

    

3. 等待所监控文件描述符上有事件的产生，类似于select()调用。

   #include 
   	int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
   		events：		用来存内核得到事件的集合，
   		maxevents：	告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，
   		timeout：	是超时时间
   			-1：	阻塞
   			0：	立即返回，非阻塞
   			>0：	指定毫秒
   		返回值：	成功返回有多少文件描述符就绪，时间到时返回0，出错返回-1
   

   服务器端代码如下

   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include 
   #include "wrap.h"
   #define MAXLINE 80
   #define SERV_PORT 6666
   #define OPEN_MAX 1024
   
   int main(int argc, char *argv[])
   {
   	int i, j, maxi, listenfd, connfd, sockfd;
   	int nready, efd, res;
   	ssize_t n;
   	char buf[MAXLINE], str[INET_ADDRSTRLEN];
   	socklen_t clilen;
   	int client[OPEN_MAX];
   	struct sockaddr_in cliaddr, servaddr;
   	struct epoll_event tep, ep[OPEN_MAX];
   
   	listenfd = Socket(AF_INET, SOCK_STREAM, 0);
   
   	bzero(&servaddr, sizeof(servaddr));
   	servaddr.sin_family = AF_INET;
   	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
   	servaddr.sin_port = htons(SERV_PORT);
   
   	Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
   
   	Listen(listenfd, 20);
   
   	for (i = 0; i < OPEN_MAX; i++)
   		client[i] = -1;
   	maxi = -1;
   
   	efd = epoll_create(OPEN_MAX);
   	if (efd == -1)
   		perr_exit("epoll_create");
   
   	tep.events = EPOLLIN; tep.data.fd = listenfd;
   
   	res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep);
   	if (res == -1)
   		perr_exit("epoll_ctl");
   
   	while (1) {
   		nready = epoll_wait(efd, ep, OPEN_MAX, -1); /* 阻塞监听 */
   		if (nready == -1)
   			perr_exit("epoll_wait");
   
   		for (i = 0; i < nready; i++) {
   			if (!(ep[i].events & EPOLLIN))
   				continue;
   			if (ep[i].data.fd == listenfd) {
   				clilen = sizeof(cliaddr);
   				connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
   				printf("received from %s at PORT %d\n", 
   						inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), 
   						ntohs(cliaddr.sin_port));
   				for (j = 0; j < OPEN_MAX; j++) {
   					if (client[j] < 0) {
   						client[j] = connfd; /* save descriptor */
   						break;
   					}
   				}
   
   				if (j == OPEN_MAX)
   					perr_exit("too many clients");
   				if (j > maxi)
   					maxi = j; 		/* max index in client[] array */
   
   				tep.events = EPOLLIN; 
   				tep.data.fd = connfd;
   				res = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);
   				if (res == -1)
   					perr_exit("epoll_ctl");
   			} else {
   				sockfd = ep[i].data.fd;
   				n = Read(sockfd, buf, MAXLINE);
   				if (n == 0) {
   					for (j = 0; j <= maxi; j++) {
   						if (client[j] == sockfd) {
   							client[j] = -1;
   							break;
   						}
   					}
   					res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);
   					if (res == -1)
   						perr_exit("epoll_ctl");
   
   					Close(sockfd);
   					printf("client[%d] closed connection\n", j);
   				} else {
   					for (j = 0; j < n; j++)
   						buf[j] = toupper(buf[j]);
   					Writen(sockfd, buf, n);
   				}
   			}
   		}
   	}
   	close(listenfd);
   	close(efd);
   	return 0;
   }
   

   客户端代码如下

   #include 
   #include 
   #include 
   #include 
   #include "wrap.h"
   #define MAXLINE 80
   #define SERV_PORT 6666
   
   int main(int argc, char *argv[])
   {
   	struct sockaddr_in servaddr;
   	char buf[MAXLINE];
   	int sockfd, n;
   
   	sockfd = Socket(AF_INET, SOCK_STREAM, 0);
   
   	bzero(&servaddr, sizeof(servaddr));
   	servaddr.sin_family = AF_INET;
   	inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
   	servaddr.sin_port = htons(SERV_PORT);
   
   	Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
   
   	while (fgets(buf, MAXLINE, stdin) != NULL) {
   		Write(sockfd, buf, strlen(buf));
   		n = Read(sockfd, buf, MAXLINE);
   		if (n == 0)
   			printf("the other side has been closed.\n");
   		else
   			Write(STDOUT_FILENO, buf, n);
   	}
   
   	Close(sockfd);
   	return 0;
   }
   

   事件模型

   EPOLL事件有两种模型：

   Edge Triggered (ET) 边缘触发只有数据到来才触发，不管缓存区中是否还有数据。ET模式即Edge Triggered工作模式。

   如果我们在第1步将RFD添加到epoll描述符的时候使用了EPOLLET标志，那么在第5步调用epoll_wait之后将有可能会挂起，因为剩余的数据还存在于文件的输入缓冲区内，而且数据发出端还在等待一个针对已经发出数据的反馈信息。只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件。因此在第5步的时候，调用者可能会放弃等待仍在存在于文件输入缓冲区内的剩余数据。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。最好以下面的方式调用ET模式的epoll接口，在后面会介绍避免可能的缺陷。

   1.基于非阻塞文件句柄

   2.只有当read或者write返回EAGAIN(非阻塞读，暂时无数据)时才需要挂起、等待。但这并不是说每次read时都需要循环读，直到读到产生一个EAGAIN才认为此次事件处理完成，当read返回的读到的数据长度小于请求的数据长度时，就可以确定此时缓冲中已没有数据了，也就可以认为此事读事件已处理完成。

   Level Triggered (LT) 水平触发只要有数据都会触发。LT模式即Level Triggered工作模式。

   与ET模式不同的是，以LT方式调用epoll接口的时候，它就相当于一个速度比较快的poll，无论后面的数据是否被使用。

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

   ET(edge-triggered)：ET是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知。请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once).