epoll简介和使用

        epoll是Linux内核为处理大批量句柄而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著减少程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。

        说起epoll，就不得不提起select。对比起select，epoll主要有下面3个优点：

        1、[句柄数] select最大句柄数受限，默认为1024（FD_SETSIZE值，可通过内核修改）；而epoll最大句柄数为进程打开文件的句柄数，只受资源限制

        2、[检查IO事件方法] select采用轮询操作去查询监听的每个句柄是否为IO事件；而epoll则在每个监听句柄上有个回调函数（callback），当句柄的IO事件发生时，会自动调用回调函数通知epoll，故epoll只需维护一个“活跃句柄”队列。这也是epoll适合大量并发连接中只有少量活跃的原因

        3、[内存拷贝] 无论是select还是epoll，都需要把内核空间的句柄消息通知给进程空间。select直接将内核空间的消息在内存上拷贝一份到用户空间；而epoll使用mmap一块内核和用户空间共用的内存来减少内存拷贝。

// =============================================================================================

先直接上代码，用一个最基础的例子来直观了解epoll。下面是使用epoll写的一个简单TCP服务器（epollSvr.cpp）：

#include <iostream> 
#include <stdio.h> 
#include <string.h>  
#include <errno.h> 
#include <fcntl.h> 
#include <sys/socket.h>  
#include <netinet/in.h>  
#include <arpa/inet.h>  
#include <netdb.h>  
using namespace std;

// epoll的头文件
#include <sys/epoll.h>

const int mMaxPending = 10;
const int mMaxBufSize = 1500;

// 将Socket设置为非阻塞模式（epoll的ET模式只支持非阻塞Socket）
int setNonblocking(int fd)
{
	if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0)|O_NONBLOCK) == -1) {
        	return -1;
	}
	return 0;
}

int main()
{
	int iSvrFd, iCliFd;
	struct sockaddr_in sSvrAddr, sCliAddr; 
	
	memset(&sSvrAddr, 0, sizeof(sSvrAddr));
	sSvrAddr.sin_family = AF_INET;
	sSvrAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  
	sSvrAddr.sin_port = htons(8888); 
	
	// 创建tcpSocket（iSvrFd），监听本机8888端口
	iSvrFd = socket(AF_INET, SOCK_STREAM, 0);
	setNonblocking(iSvrFd);
	bind(iSvrFd, (struct sockaddr*)&sSvrAddr, sizeof(sSvrAddr));
	listen(iSvrFd, mMaxPending);

	int i, iEpollFd, iCnt;
	struct epoll_event sEvent, sEvents[10];

	// 1.epoll_create(int maxfds)：创建一个epoll句柄，maxfds为这个epoll支持的最大句柄数
	iEpollFd = epoll_create(256);

	// 将上面的tcpSocket构造为epoll的Event
	sEvent.data.fd = iSvrFd;
	sEvent.events = EPOLLIN|EPOLLET;

	// 2.epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)：epoll的事件控制函数，用来注册/修改/删除事件。
	// 这里将刚构建的Event注册进来
	epoll_ctl(iEpollFd, EPOLL_CTL_ADD, iSvrFd, &sEvent);
	
	while(1)
	{
		// 3.int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)
		// 查询网络接口，检测在epoll注册的所有句柄有没有IO事件发生
		iCnt = epoll_wait(iEpollFd, sEvents, 10, 1000);
		for(i = 0; i < iCnt; i ++)
		{
			if (sEvents[i].data.fd == iSvrFd) 
			{
				// A.tcpSocket有事件发生，证明有新连接请求
				socklen_t iSinSize = sizeof(sCliAddr);
				iCliFd = accept(iSvrFd, (struct sockaddr*)&sCliAddr, &iSinSize);
				cout << "New Con From " << inet_ntoa(sCliAddr.sin_addr) << ":" << sCliAddr.sin_port << endl;
				setNonblocking(iCliFd);

				// 将新的客户端连接注册到epoll
   				sEvent.data.fd = iCliFd;
				sEvent.events = EPOLLIN|EPOLLET;
				epoll_ctl(iEpollFd, EPOLL_CTL_ADD, iCliFd, &sEvent);
			}
			else if (sEvents[i].events & EPOLLIN)
			{
				// B.客户端连接读事件
				// 这里分2种情况，客户端发送过来数据包，或者客户端关闭连接，都会触发EPOLLIN
				cout << "[EPOLLIN]" << endl;
				
				int iLen;
				char buf[mMaxBufSize+1];
				// 调用recv接收客户端发送过来的数据包
				if ((iLen = recv(iCliFd, buf, mMaxBufSize, 0)) < 0) {
					perror("Recv Err");
					continue;
				}
				
				if (iLen == 0) {
					cout << "Con Closed" << endl;
					// 没有接收到数据，证明为客户端关闭连接了，调用close注销句柄，epoll会自动将其对应的Event移除
					close(iCliFd);
					continue;
				}

				buf[iLen] = 0;
				cout << "Recv Info:" << buf << endl;

				// 收到数据后，将这个客户端连接注册为EPOLLOUT，在缓冲区不满时会触发写事件
   				sEvent.data.fd = iCliFd;
				sEvent.events = EPOLLOUT|EPOLLET;
				epoll_ctl(iEpollFd, EPOLL_CTL_MOD, iCliFd, &sEvent);
			}
			else if (sEvents[i].events & EPOLLOUT)
			{
				// C.客户端连接写事件
				cout << "[EPOLLOUT]" << endl;

				// 调用send发送数据给客户端
				if (send(iCliFd, "Hello New Cli!", 14, 0) < 0) {
					cout << "Send Err, Info:" << strerror(errno) << endl;
					continue;
				} else {
					cout << "Send Suc" << endl;
				}

				// 发送完数据后，再将这个客户端连接注册给EPOLLIN，等待客户端反应
   				sEvent.data.fd = iCliFd;
				sEvent.events = EPOLLIN|EPOLLET;
				epoll_ctl(iEpollFd, EPOLL_CTL_MOD, iCliFd, &sEvent);
			}
		}
	}

	return 0;
}

用Python写一个简答的TCP客户端来测试（tcpCli.py）：

import socket

if __name__=='__main__':
	addr = ('127.0.0.1', 8888);
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
	sock.connect(addr);
	sock.send("Hello Libevent, I`m Cli A");
	buf = sock.recv(1500);
	print buf
	sock.close()

服务端编译并运行：

[yiran@localhost epoll]$ g++ -o svr epollSvr.cpp 
[yiran@localhost epoll]$ ./svr 
New Con From 127.0.0.1:63937
[EPOLLIN]
Recv Info:Hello Libevent, I`m Cli A
[EPOLLOUT]
Send Suc
[EPOLLIN]
Con Closed

客户端运行：

[yiran@localhost epoll]$ python tcpCli.py 
Hello New Cli!

        这里简单分析下：

        1、当客户端调用sock.connect( )，触发epoll事件，服务端if (sEvents[i].data.fd == iSvrFd){ }成立，建立新连接，输出“New Con From 127.0.0.1:63937”

        2、当客户端调用sock.send( )，触发epoll事件，服务端if (sEvents[i].events & EPOLLIN){ }成立，读取客户端发送数据，输出“[EPOLLIN] Recv Info:Hello Libevent, I`m Cli A”

        3、服务端在第2步时注册了EPOLLOUT，当写缓冲没有满时，会自动触发epoll事件，服务端if (sEvents[i].events & EPOLLOUT) { }，向客户端发送数据，输出“[EPOLLOUT] Send Suc”

        4、当客户端调用sock.close( )，触发epoll事件，服务端if (sEvents[i].events & EPOLLIN){ }成立，读取不到客户端发送数据，证明为客户端关闭连接了，所以注销句柄，输出“[EPOLLIN] Con Closed”

// =============================================================================================

        * epoll的2种触发模式

        1、水平模式：Level Triggered（LT），默认工作方式。支持阻塞和非阻塞Socket。这种模式下，epoll会告诉你某个句柄有IO事件，如果你没有处理（epoll_wait()出来之后没有accept或者read等），其会一直通知下去

        2、边缘触发：Edge Triggered（ET），高速工作方式。只支持非阻塞Socket（为什么？）。这种模式下，epoll只会将句柄的IO事件通知你一次，如果你没有处理，这个IO事件将会丢失

        * epoll相关的数据结构

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;

        其中events为事件类型，为下面几个宏的集合：

        EPOLLIN ：文件描述符可以读（包括客户端connect，send/sendto，close）；
        EPOLLOUT：文件描述符可以写；
        EPOLLPRI：文件描述符有紧急的数据可读；
        EPOLLERR：文件描述符发生错误；
        EPOLLHUP：文件描述符被挂断；
        EPOLLET： 将epoll设为ET触发模式，因为默认为LT触发。
        EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

        比如你要以ET触发模式监听某句柄的读事件，则设events=EPOLLIN|EPOLLET

        * epoll的3个相关函数

        epoll的API还是很简单的，只有3个函数，epoll_create( ) / epoll_ctl( ) / epoll_wait( )

        1、epoll_create(int maxfds)：创建一个epoll句柄，maxfds为这个epoll支持的最大句柄数

        2、int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)：事件控制函数，用来注册/修改/删除事件

        第一个参epfd为调用epoll_create( )创建的epoll句柄

        第二个参op为事件类型，EPOLL_CTL_ADD为注册，EPOLL_CTL_MOD为修改，EPOLL_CTL_DEL为删除

        第三个参fd为要监听的句柄

        第四个参event为这个监听事件的具体信息，如要监听这个句柄的读事件还是写

        尽量少地调用epoll_ctl，防止其所引来的开销抵消其带来的好处。有的时候，应用中可能存在大量的短连接（比如说Web服务器），epoll_ctl将被频繁地调用，可能成为这个系统的瓶颈

        3、int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)：调用一次，epoll就查询当前的网络接口，检测在epoll注册的所有句柄有没有IO事件发生

        第一个参epfd为epoll句柄
        第二个参events作为一个回参，存放epoll检测到有IO事件发生的句柄信息
        第三个参maxevents为第二个参events的长度
        第四个参timeout为调用epoll_wait( )的超时时间，单位为ms（0表示立即返回，即非阻塞；-1表示阻塞）

        * EPOLLOUT事件什么时候被触发？

        这个问题是我一开始学习epoll时有些不解的，因为客户端给服务端发送数据，服务端的接收缓冲区有数据可读而触发EPOLLIN事件。但是写事件是服务端的一个主动行为，服务端怎么主动自己触发自己？

        后来发现这个问题其实很简单，就是只要“缓冲区不满”，服务端能写数据，就会一直触发EPOLLOUT。

        * 怎么判断客户端连接结束并将对应句柄从epoll中删去？

        1、当客户端断开连接，会触发EPOLLIN事件。所以如果在EPOLLIN逻辑里，read返回0（读不到数据，且没有出错），可判断为客户端连接结束。

        2、只要将客户端对应的句柄close( )掉，epoll自动会将其从监听句柄中删去。