epoll用法

以下内容整理自网络。

1、epoll的优点：

（1）支持一个进程打开大数量的socket描述符（FD），这个数目和系统的内存有关，可以查看/proc/sys/fs/file-max来查看；

（2）epoll只对活跃的socket进行操作，而不必轮询所有的描述符，因此IO效率不会随着FD的增加而线型下降；

（3）epoll使用mmap使内核和用户空间共享同一块内存，可以加快内核与用户空间之间的消息传递；

2、epoll的工作模式：

（1）LT：水平触发模式为缺省的工作方式，同时支持block和no-block socket。这种模式下内核会通知你一个文件描述符是否就绪，如果不进行任何操作，那么内核还是会继续通知你。

（2）ET：边缘触发模式是高速工作方式，只支持no-block socket。在该模式下，如果某个文件描述符就绪，内核只会通知你一次，直到某个操作导致该文件描述符不再是就绪状态。

3、相关接口：

（1）int creat_epoll(int maxfds)

创建一个epoll句柄，参数maxfds告诉内核该epoll支持的最大句柄数。该函数会返回一个句柄，之后的所有操作都是通过该句柄来完成的。在用完之后要调用close（）来关闭这个epoll句柄，避免fd被耗尽。

（2）int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

epfd：epoll的句柄，creat_epoll()的返回值；

op：表示动作，用三个宏表示：EPOLL_CTL_ADD(注册新的fd到epfd)，EPOLL_CTL_MOD(修改已经注册的fd的监听事件)，EPOLL_CTL_DEL(从epfd删除一个fd)；

fd：需要监听的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;

其中epol_event中的event可以用以下几个宏的集合：

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)

该函数返回要处理的读写事件的数目，返回0表示超时。

epfd：epoll句柄；

event：从内核得到的事件集合，存储所有的读写事件；

maxevents：告知内核这个events有多大，当前需要监听的所有socket句柄数，它可能大于创建epoll句柄时的最大值maxfds；

timeout：超时时间，毫秒级，0表示马上返回，-1表示阻塞，正整数表示等待时间。

4、实现步骤

（1）用epoll_creat()创建文件描述符，设置最大连接数；

（2）创建与epoll相关的接收线程，应用程序可以创建多个接收线程来处理epoll上的读通知事件，线程的数量依赖于程序的具体需要；

（3）创建一个非阻塞模式的描述符来监听socket，调用listen()侦听有无新连接，使用epoll_ctl注册事件；

（4）调用epoll_wait()启动网络监听循环，等待epoll事件发生；

（5）如果epoll事件表明有新连接，则调用accept()接受连接，设置该新连接为非阻塞，设置事件，注册事件；

         如果epoll事件表明有可读数据，则将该描述符加入可读队列，接收线程读入数据并处理；

         如果epoll事件表明有数据可写，则进行写操作。

5、例子

#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
 
#define MAXLINE 10 
#define OPEN_MAX 100 
#define LISTENQ 20 
#define SERV_PORT 5555 
#define INFTIM 1000
 
//线程池任务队列结构体
 
struct task
{
	int fd; //需要读写的文件描述符
	struct task *next; //下一个任务
};
 
//用于读写两个的两个方面传递参数
struct user_data
{
	int fd;
	unsigned int n_size;
	char line[MAXLINE];
};
 
//线程的任务函数
void * readtask(void *args);
void * writetask(void *args);
//声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
struct epoll_event ev, events[20];
int epfd;
pthread_mutex_t mutex;
pthread_cond_t cond1;
struct task *readhead = NULL, *readtail = NULL, *writehead = NULL;
void setnonblocking(int sock)
{
	int opts;
	opts = fcntl(sock, F_GETFL);//fcntl函数改变已打开文件的性质
	if (opts < 0)
	{
		perror("fcntl(sock,GETFL)");
		exit(1);
	}
	opts = opts | O_NONBLOCK;
	if (fcntl(sock, F_SETFL, opts) < 0)
	{
		perror("fcntl(sock,SETFL,opts)");
		exit(1);
	}
}
int main()
{
	int i, maxi, listenfd, connfd, sockfd, nfds;
	pthread_t tid1, tid2;

	struct task *new_task = NULL;
	struct user_data *rdata = NULL;
	socklen_t clilen;

	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond1, NULL);
	//初始化用于读线程池的线程

	pthread_create(&tid1, NULL, readtask, NULL);
	pthread_create(&tid2, NULL, readtask, NULL);

	//生成用于处理accept的epoll专用的文件描述符
	epfd = epoll_create(256);
 
	struct sockaddr_in clientaddr;
	struct sockaddr_in serveraddr;
	listenfd = socket(AF_INET, SOCK_STREAM, 0);
	//把socket设置为非阻塞方式
	setnonblocking(listenfd);
	//设置与要处理的事件相关的文件描述符
	ev.data.fd = listenfd;
	//设置要处理的事件类型
	ev.events = EPOLLIN | EPOLLET;
	//注册epoll事件
	epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
	bzero(&serveraddr, sizeof(serveraddr));
	serveraddr.sin_family = AF_INET;
	char *local_addr = "200.200.200.222";
	inet_aton(local_addr, &(serveraddr.sin_addr));//htons(SERV_PORT);
	serveraddr.sin_port = htons(SERV_PORT);
	bind(listenfd, (sockaddr *) &serveraddr, sizeof(serveraddr));
	listen(listenfd, LISTENQ);
	maxi = 0;
	for (;;)
	{
		//等待epoll事件的发生
		nfds = epoll_wait(epfd, events, 20, 500);
		//处理所发生的所有事件
		for (i = 0; i < nfds; ++i)
		{
			if (events[i].data.fd == listenfd)
			{
				connfd = accept(listenfd, (sockaddr *) &clientaddr, &clilen);
				if (connfd < 0)
				{
					perror("connfd<0");
					exit(1);
				}
				setnonblocking(connfd);
				char *str = inet_ntoa(clientaddr.sin_addr);
				std::cout << "connec_ from >>" << str << std::endl;
				//设置用于读操作的文件描述符
				ev.data.fd = connfd;
				//设置用于注测的读操作事件
				ev.events = EPOLLIN | EPOLLET;
				//注册ev
				epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
			} 
			else if (events[i].events & EPOLLIN)
			{
				printf("reading!\n");
				if ((sockfd = events[i].data.fd) < 0) continue;
				new_task = new task();
				new_task->fd = sockfd;
				new_task->next = NULL;
				//添加新的读任务
				pthread_mutex_lock(&mutex);
				if (readhead == NULL)
				{
					readhead = new_task;
					readtail = new_task;
				} else
				{
					readtail->next = new_task;
					readtail = new_task;
				}
				//唤醒所有等待cond1条件的线程
				pthread_cond_broadcast(&cond1);
				pthread_mutex_unlock(&mutex);
			} 
			else if(events[i].events & EPOLLOUT)
			{
				rdata = (struct user_data *) events[i].data.ptr;
				sockfd = rdata->fd;
				write(sockfd, rdata->line, rdata->n_size);
				delete rdata;
				//设置用于读操作的文件描述符
				ev.data.fd = sockfd;
				//设置用于注测的读操作事件
				ev.events = EPOLLIN | EPOLLET;
				//修改sockfd上要处理的事件为EPOLIN
				epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
			}
		}
	}
}
void * readtask(void *args)
{
	int fd = -1;
	unsigned int n;
	//用于把读出来的数据传递出去
	struct user_data *data = NULL;
	while (1)
	{
		pthread_mutex_lock(&mutex);
		//等待到任务队列不为空
		while (readhead == NULL)
	        pthread_cond_wait(&cond1, &mutex);
		fd = readhead->fd;
		//从任务队列取出一个读任务
		struct task *tmp = readhead;
		readhead = readhead->next;
		delete tmp;
		pthread_mutex_unlock(&mutex);
		data = new user_data();
		data->fd = fd;
		if ((n = read(fd, data->line, MAXLINE)) < 0)
		{
			if (errno == ECONNRESET)
			{
				close(fd);
			} 
			else
			{
				std::cout << "readline error" << std::endl;
			}
			if (data != NULL)
			{
				delete data;
			}
		} 
		else if (n == 0)
        {
             close(fd);
             printf("Client close connect!\n");
             if (data != NULL) delete data;
        } 
        else
        {
             data->n_size = n;
             //设置需要传递出去的数据
             ev.data.ptr = data;
             //设置用于注测的写操作事件
             ev.events = EPOLLOUT | EPOLLET;
             //修改sockfd上要处理的事件为EPOLLOUT
             epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
        }
    }
}