Linux下IO多路转接技术之epoll

在学习linux套接字编程的进阶阶段，写下对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就绪通知⽅法。

在了解epoll之前，我们要了解两个函数：

 select(2) 和 poll(2) 函数的功能：

• select(2) 一次可以监测 FD_SETSIZE数量大小的描述符，FD_SETSIZE 通常是一个在 libc 编译时指定的小数字。
• poll(2) 一次可以监测的描述符数量并没有限制，但撇开其它因素，我们每次都不得不检查就绪通知，线性扫描所有通过描述符，这样时间复杂度为 O(n)而且很慢。

epoll 没有这些固定限制，也不执行任何线性扫描。因此它可以更高效地执行和处理大量事件。

二。epoll的函数及其功能：

1. int epoll_create(int size);
创建⼀个epoll的句柄。⾃从linux2.6.8之后，size参数是被忽略的。需要注意的是，当创建好epoll句柄后，它就是会占⽤⼀个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使⽤完epoll后，必须调⽤close()关闭，否则可能导致fd被耗尽。
2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函数，它不同于select()是在监听事件时告诉内核要监听什么类型的事件，⽽是在这⾥先注册要监听的事件类型。
第⼀个参数是epoll_create()的返回值。
第⼆个参数表⽰动作，⽤三个宏来表⽰：

EPOLL_CTL_ADD：注册新的fd到epfd中；

EPOLL_CTL_MOD：修改已经注册的fd的监听事件；

EPOLL_CTL_DEL：从epfd中删除⼀个fd；

第三个参数是需要监听的fd。
第四个参数是告诉内核需要监听什么事。struct epoll_event结构体如下：

<span style="font-family:Microsoft YaHei;">typedef union epoll_data
{
  void        *ptr;
  int          fd;
  __uint32_t   u32;
  __uint64_t   u64;
} epoll_data_t;
 
struct epoll_event
{
  __uint32_t   events; /* Epoll events */
  epoll_data_t data;   /* User data variable */
};</span>

events可以是以下⼏个宏的集合：

EPOLLIN ：表⽰对应的⽂件描述符可以读（包括对端SOCKET正常关闭）；

EPOLLOUT：表⽰对应的⽂件描述符可以写；

EPOLLPRI：表⽰对应的⽂件描述符有紧急的数据可读（这⾥应该表⽰有带外数据到来）；

EPOLLERR：表⽰对应的⽂件描述符发⽣错误；

EPOLLHUP：表⽰对应的⽂件描述符被挂断；

EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于⽔平触发(LevelTriggered)来说的。

EPOLLONESHOT：只监听⼀次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加⼊到EPOLL队列⾥。

3.int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待在epoll监控的事件中已经发生的事件。参数events是分配好的epoll_event结构体数组，epoll将会把发⽣的事件赋值到events数组中（events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在⽤户态中分配内存）。maxevents告之内核这个events有多⼤，这个 maxevents的值不能⼤于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会⽴即返回，-1将不确定，也有说法说是永久阻塞）。如果函数调⽤成功，返回对应I/O上已准备好的⽂件描述符数⽬，如返回0表⽰已超时。

epoll的工作方式：

LT：水平触发，效率会低于ET触发，尤其在大并发，大流量的情况下。但是LT对代码编写要求比较低，不容易出现问题。LT模式服务编写上的表现是：只要有数据没有被获取，内核就不断通知你，因此不用担心事件丢失的情况。
ET：边缘触发，效率非常高，在并发，大流量的情况下，会比LT少很多epoll的系统调用，因此效率高。但是对编程要求高，需要细致的处理每个请求，否则容易发生丢失事件的情况。
下面举一个列子来说明LT和ET的区别（都是非阻塞模式，阻塞就不说了，效率太低）：
采用LT模式下， 如果accept调用有返回就可以马上建立当前这个连接了，再epoll_wait等待下次通知，和select一样。
但是对于ET而言，如果accpet调用有返回，除了建立当前这个连接外，不能马上就epoll_wait还需要继续循环。

三。基于epoll的网络服务器实例代码：

现在开始写代码。我们要实现的是一个可以接受到客户端连接的并回显一条消息的服务器。

首先我们要创建套接字并绑定：

<span style="font-family:Microsoft YaHei;">static int startup(const char* _ip,int _port)
{
	int sock=socket(AF_INET,SOCK_STREAM,0);
	if(sock<0)
	{
		perror("socket");
		exit(2);
	}

	struct sockaddr_in local;
	local.sin_family=AF_INET;
	local.sin_port=htons(_port);//host to net
	local.sin_addr.s_addr=inet_addr(_ip);

	if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
	{
		perror("bind");
		exit(3);
	}

	if(listen(sock,5)<0)
	{
		perror("listen");
		exit(4);
	}
	return sock;
}</span>

现在我们已经得到了一个监听套接字，我们接下来需要做的是将这个套接字托管给epoll。

<span style="white-space:pre">	<span style="font-family:Microsoft YaHei;">int main(int argc,const char* argv[])
{
<span style="white-space:pre">	</span>if(argc!=3)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>Usage(argv[0]);
<span style="white-space:pre">		</span>exit(1);
<span style="white-space:pre">	</span>}</span></span>

<span style="font-family:Microsoft YaHei;"><span style="white-space:pre">	</span>int listen_sock=startup(argv[1],atoi(argv[2]));</span>

<span style="font-family:Microsoft YaHei;">	int epfd=epoll_create(256);
	if(epfd<0)
	{
		perror("epoll_create");
		exit(5);
	}

	struct epoll_event _ev;
	_ev.events=EPOLLIN;
	_ev.data.fd=listen_sock;

	epoll_ctl(epfd,EPOLL_CTL_ADD,listen_sock,&_ev);

	struct epoll_event _ready_ev[128];//create ready queue
	int _ready_evs=128;
	int _timeout=-1;//block

	int nums=0;//num of fd_ready</span>

创建好epoll并且将监听套接字添加到epoll的事件集中，我们就只需要等待客户端的链接请求，也就是某个事件发生。会将事件的文件描述符给添加到就绪队列中。每次，epoll只需要遍历一遍就绪队列就可以知道到底是有多少个事件已经就绪，而不像select一样需要遍历整个描述符集。

以下是epoll的主逻辑：

<span style="font-family:Microsoft YaHei;">while(1)
	{
		switch((nums=epoll_wait(epfd,_ready_ev,_ready_evs,_timeout)))//wait n fd ready
		{
			case 0:
				printf("timeout......\n");
				break;
			case -1:
				perror("epoll_wait");
				break;
			default:
				{
					int i=0;
					for(;i<nums;++i)
					{
						int _fd=_ready_ev[i].data.fd;
						if(_fd==listen_sock && _ready_ev[i].events & EPOLLIN)//get a link
						{
							struct sockaddr_in peer;
							socklen_t len=sizeof(peer);
							int new_sock=accept(listen_sock,(struct sockaddr*)&peer,&len);
							if(new_sock>0)
							{
								printf("client info,socket:%s:%d\n",inet_ntoa(peer.sin_addr),ntohs(peer.sin_port));
								_ev.events=EPOLLIN | EPOLLET;//ET
								_ev.data.fd=new_sock;

								set_noblock(new_sock);

								epoll_ctl(epfd,EPOLL_CTL_ADD,new_sock,&_ev);
							}
						}else
						{
							if(_ready_ev[i].events & EPOLLIN)
							{
								char buf[102400];
								memset(buf,'\0',sizeof(buf));
								ssize_t _s=recv(_fd,buf,sizeof(buf)-1,0);
								if(_s>0)
								{
									printf("client#%s\n",buf);
									_ev.events=EPOLLOUT | EPOLLET;
									_ev.data.fd=_fd;
									epoll_ctl(epfd,EPOLL_CTL_MOD,_fd,&_ev);
								}else if(_s==0)
								{
									printf("client close....\n");
									epoll_ctl(epfd,EPOLL_CTL_DEL,_fd,NULL);
									close(_fd);
								}else
								{
									perror("recv");
									exit(6);
								}
							}else if(_ready_ev[i].events & EPOLLOUT)
							{
								const char* msg="HTTP/1.1 200 OK\r\n\r\n<h1>hello world =_=||</h1>\r\n";
								send(_fd,msg,strlen(msg),0);
								epoll_ctl(epfd,EPOLL_CTL_DEL,_fd,NULL);
								close(_fd);
							}
						}
					}
				}
				break;
		}
	}</span>

<span style="font-family:Microsoft YaHei;">static int set_noblock(int sock)
{
	int fl=fcntl(sock,F_GETFL);
	return fcntl(sock,F_SETFL,fl | O_NONBLOCK);
}</span>

至此，一个服务器就写好了。我们可以打开自己的浏览器输入127.0.0.1：8080通过本机环回来测试。

测试结果如图：