Linux-(C)IO多路复用之epoll学习（转载）

转载出处：http://www.cnblogs.com/Anker/archive/2013/08/17/3263780.html

本文实例比较简单，内容均转载。

1、基本知识

　　epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

2、epoll接口

　　epoll操作过程需要三个接口，分别如下：

#include <sys/epoll.h>
int epoll_create(int size);
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);

（1） int epoll_create(int size);
　　创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好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的事件注册函数，它不同与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 */
};

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

（3） int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
　　等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

3、工作模式

　　epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：

　　LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。

　　ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

　　ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

4、测试程序（自己写，跟转载实例不同）

　　写一个TCP回射程序，程序的功能是：客户端向服务器发送信息，服务器接收并原样发送给客户端，客户端显示出接收到的信息。

服务端程序如下所示：

server

/*
 * epoll.c
 *
 *  Created on: 2016年7月30日
 *      Author: Andy_Cong
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/epoll.h>
/* According to earlier standards */
#include <sys/time.h>
#include <unistd.h>

#define MAX 100

void setnonblock(int st)
{
	//fcntl
	int opts=fcntl(st,F_GETFL);
	if(opts<0)
	{
		printf("fcntl failed %s\n",strerror(errno));
		return ;
	}
	opts=opts | O_NONBLOCK;
	if(fcntl(st,F_SETFL,opts)<0)
	{
		printf("fcntl failed %s\n",strerror(errno));
	}
	return ;
}
//server create
int socket_create(int port)
{
	int st=socket(AF_INET,SOCK_STREAM,0);
	int on=1;
	//IP可重用
	if(setsockopt(st,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))==-1)
	{
		printf("setsockopt fail %s\n",strerror(errno));
		return 0;
	}

	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(addr));
	addr.sin_family=AF_INET;
	addr.sin_port=htons(port);
	addr.sin_addr.s_addr=htonl(INADDR_ANY);

	if(bind(st,(struct sockaddr *)&addr,sizeof(addr))==-1)
	{
		printf("bind fail:%s\n",strerror(errno));
		return 0;
	}
	if(listen(st,300)==-1)
	{
		printf("listen fail:%s\n",strerror(errno));
		return 0;
	}
	return st;
}

int socket_accept(int listen_st)
{
	struct sockaddr_in client_addr;
	socklen_t len=sizeof(client_addr);
	memset(&client_addr,0,sizeof(client_addr));
	//return the client descriptor that is listened
	int client_st=accept(listen_st,(struct sockaddr *)&client_addr,&len);
	if(client_st<0)
	{
		printf("accept failed %s\n",strerror(errno));
	}
	else
	{
		printf("accept by %s\n",inet_ntoa(client_addr.sin_addr));
	}
	return client_st;
}

ssize_t socket_recv(int st)
{
	char buf[1024];
	memset(buf,0,sizeof(buf));
	ssize_t rc=recv(st,buf,sizeof(buf),0);
	if(rc<0)
	{
		printf("recv failed %s\n",strerror(errno));
	}
	else
	{
		//收什么发什么
		printf("recv %s\n",buf);
		send(st,buf,rc,0);
	}
	return rc;
}


int main(int argc,char *argv[])
{
	if(argc<2)
	{
		printf("argument: Program Port\n");
		return EXIT_FAILURE;
	}
	int port=atoi(argv[1]);
	int listen_st=socket_create(port);
	if(listen_st==0)
	{
		printf("listen fail: %s\n", strerror(errno));
		return -1;
	}
	setnonblock(listen_st);
	int epfd=epoll_create(MAX); //创建一个大小为MAX的poll，

	struct epoll_event ev,events[MAX]; //定义结构
	ev.data.fd=listen_st;       //设置与要处理的事件相关的文件描述符号
	ev.events=EPOLLIN | EPOLLERR | EPOLLHUP; //监听可写，出错，挂段
	//EPOLL_CTL_ADD 将注册新的listen放到epfd
	epoll_ctl(epfd,EPOLL_CTL_ADD,listen_st,&ev); //放入poll
	int st=0;
	while(1)
	{
		//返回多少个socket准备就绪
		int nfds=epoll_wait(epfd,events,100,-1);
		if(nfds==-1)
		{
			printf("epoll_wait fail %s\n",strerror(errno));
			break;
		}
		int i;
		//对响应信息一一处理
		for(i=0;i<nfds;++i)
		{
			if(events[i].data.fd<0)
				continue;
			//监测到一个socket链接到server
			if(events[i].data.fd==listen_st)
			{
				st=socket_accept(listen_st);
				if(st>=0)
				{
					setnonblock(st);
					ev.data.fd=st;
					ev.events=EPOLLIN | EPOLLERR | EPOLLHUP;
					epoll_ctl(epfd,EPOLL_CTL_ADD,st,&ev);
					continue;
				}
			}

			/*client端的socket有事件到达*/
			if(events[i].events&EPOLLIN)  //socket发送过来数据
			{
				st=events[i].data.fd;
				if(socket_recv(st)<0)
				{
					close(st);
					events[i].data.fd=-1;
				}
			}
			if(events[i].events&EPOLLERR) //socket出错
			{
				st=events[i].data.fd;
				close(st);
				ev.data.fd=st;
				ev.events=EPOLLIN | EPOLLERR | EPOLLHUP;
				epoll_ctl(epfd,EPOLL_CTL_DEL,st,&ev);//删除
				events[i].data.fd=-1;
			}
			if(events[i].events&EPOLLHUP) //socket 挂断
			{
				st=events[i].data.fd;
				close(st);
				ev.data.fd=st;
				ev.events=EPOLLIN | EPOLLERR | EPOLLHUP;
				epoll_ctl(epfd,EPOLL_CTL_DEL,st,&ev);//删除
				events[i].data.fd=-1;
			}
		}
	}
	close(epfd);
	return 0;
}

client

/*
 * client.c
 *
 *  Created on: 2016年7月30日
 *      Author: Andy_Cong
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>


int main(int argc,char *argv[])
{
	if(argc<3)
	{
		printf("argument: Promgram Hostname Port\n");
		return EXIT_FAILURE;
	}
	int sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(sockfd==-1)
	{
		printf("sockfd open error: %s\n",strerror(errno));
		return -1;
	}
	int port=atoi(argv[2]);
	struct sockaddr_in addr;
	memset(&addr, 0, sizeof(addr));
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = inet_addr(argv[1]);

	if(connect(sockfd,(struct sockaddr *)&addr,sizeof(addr))==-1)
	{
	    printf("connect fail: %s\n",strerror(errno));
	    return -1;
	}
	char buf[1024];
	while (1)
	{
		memset(buf, 0, sizeof(buf));
		read(STDIN_FILENO, buf, sizeof(buf)); //从键盘获取输入
		ssize_t sd_size = send(sockfd, buf, sizeof(buf), 0);
		if(sd_size == -1)
		{
			printf("send fail: %s\n", strerror(errno));
			return -1;
		}
		memset(buf, 0, sizeof(buf));
		ssize_t rd_size = recv(sockfd, buf, sizeof(buf), 0);
		if(rd_size == -1)
		{
			printf("recv fail: %s\n", strerror(errno));
			break;
		}
		printf("client recv is:%s\n", buf);
	}
	return 0;
}

运行结果：