（转）epoll详解

本文全文转载于：https://blog.csdn.net/MOU_IT/article/details/88841556

1、epoll的函数接口：

（1）int epoll_create(int size)：

创建一个epoll的句柄，成功则返回 epoll 专用的文件描述符epfd，失败返回
-1。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的事件注册函数，成功返回0，失败返回-1。它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：

EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；

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

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 */
};

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()调用，该函数成功则返回需要处理的事件数目，如返回0表示已超时，失败则返回-1。参数events用来从内核中的就绪队列中拷贝出就绪的文件描述符。不可以是空指针，内核只负责将数据拷贝到这里，不会为我们开辟空间。maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。

2、关于ET和LT两种工作模式（参考）：
epoll事件分发系统可以运转在两种模式下：边缘触发Edge Triggered (ET)、水平触发Level Triggered (LT)：
（1）当采用水平触发通知时，我们可以在任意时刻检查文件描述符的就绪状态。这表示当我们确定了文件描述符处于就绪状态时（比如存在有输入数据），就可以对其执行一些I/O操作，然后重复检查文件描述符，看看是否仍然处于就绪态（比如还有更多的输入数据），此时我们就能执行更多的I/O。举个例子，比如说我们采用epoll水平触发模式监听一个文件描述符的可读，当这个文件可读就绪时，epoll会触发一个通知，然后我们执行一次读取操作，但这次操作我们并没有把该文件描述符的数据全部读取完。当下一次调用epoll监听该文件描述符时，epoll还会再次触发通知，直到该事件被处理完。这就意味着，当epoll触发通知后，我们可以不立即处理该事件，当下次调用epoll监听时，然后会再次向应用程序通告此事件，此时我们再处理也不晚。 水平触发模式支持阻塞I/O和非阻塞I/O。

（2）当我们采用边沿触发时，只有当I/O事件发生时我们才会收到通知。还是上个例子，如果这次我们采用epoll的边沿触发模式监听一个文件描述符的可读，当可读就绪时，epoll会触发一个通知，如果我们此时不立即处理该事件，当下次再调用epoll监听时，虽然该文件描述符的状态是可读的，但是此时epoll并不会再给应用程序发送通知。因为在边沿触发工作模式下，只有下一个新的I/O事件到来时，才会再次发送通知。另外，当文件描述符收到I/O事件通知时，通常我们并不知道要处理多少I/O（例如有多少字节可读）。因此，采用边沿触发通知程序通常要按照如下规则来设计（边缘触发模式只支持非阻塞I/O）：

1）在接收到一个I/O事件通知后，程序在某个时刻应该在相应的文件描述符上尽可能多地执行I/O（比如尽可能多地读取字节）。如果程序没这么做，那么就可能失去执行I/O的机会。因为直到产生另一个I/O事件为止，在此之前程序都不会再接收到通知了，因此也就不知道此时应该执行I/O操作。

2）如果程序采用循环来对文件描述符执行尽可能多的I/O，而文件描述符又被设置为可阻塞的，那么最终当没有更多的I/O可执行时，I/O系统调用就会阻塞。基于这个原因，每个被检查的文件描述符通常应该置为非阻塞模式，在得到I/O事件通知后重复执行I/O操作，直到相应的系统调用(比如read(),write())以错误码EAGAIN或EWOULDBLOCK的形式失败。

/ 修改cfd为非阻塞读 /

flag  = fcntl(cfd, F_GETFL);
flag |= O_NONBLOCK;
fcntl(connect_fd, F_SETFL, flag); 

总结（参考）：

水平触发：0为无数据，1为有数据。缓冲区有数据则一直为1，则一直触发。 缓冲区有数据可读，触发 ⇒ 水平触发 ；
边沿触发：0为无数据，1为有数据，只要在0变到1的上升沿才触发。 缓冲区有数据到来，触发 ⇒ 边沿触发 。

下表是I/O多路复用select,poll和epoll所支持的通知模型：

I/O模式 水平触发 边沿触发
select() 支持 不支持
poll() 支持 不支持
epoll() 支持 支持

3、epoll通用框架：

for( ; ; )
{
    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); //accept这个连接
            ev.data.fd = connfd;
            ev.events = EPOLLIN|EPOLLET;
            epoll_ctl(epfd,EPOLL_CTL_ADD,connfd, &ev); //将新的fd添加到epoll的监听队列中
        }
        else if(events[i].events&EPOLLIN )             //套接字可读时接收到数据，读socket
        {
            n = read(sockfd, line, MAXLINE)) < 0       //从网络套接字读数据
            ev.data.ptr = md;                          //md为自定义类型，添加数据
            ev.events=EPOLLOUT|EPOLLET;                //修改为监听的事件为可写模式
            epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);  //修改标识符，等待下一个循环时发送数据，异步处理的精髓
        }
        else if(events[i].events&EPOLLOUT)             //套接字可写时发送数据，写socket
        {
            struct myepoll_data* md = (myepoll_data*)events[i].data.ptr;   //取数据
            sockfd = md->fd;
            send( sockfd, md->ptr, strlen((char*)md->ptr), 0 );            //发送数据
            ev.data.fd=sockfd;
            ev.events=EPOLLIN|EPOLLET;                //修改监听的事件为可读模型
            epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); //修改标识符，等待下一个循环时接收数据
        }
        else
        {
            //其他的处理
        }
    }
}

4、完整的服务器端例子：

#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 <errno.h>
using namespace std;
 
#define MAXLINE 5
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 5000
#define INFTIM 1000
 
// 设置为非阻塞模式
void setnonblocking(int sock){
    int opts;
    opts = fcntl(sock,F_GETFL);
    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 argc, char* argv[]){
    int i, maxi, listenfd, connfd, sockfd,epfd,nfds, portnumber;
    ssize_t n;
    char line[MAXLINE];
    socklen_t clilen;
    if ( 2 == argc ){
        if( (portnumber = atoi(argv[1])) < 0 ){
            fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]);
            return 1;
        }
    }
    else{
        fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]);
        return 1;
    }
    
    struct epoll_event ev,events[20];            //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件   
    epfd=epoll_create(256);                      //生成用于处理accept的epoll专用的文件描述符
    struct sockaddr_in clientaddr;               //声明客户端地址
    struct sockaddr_in serveraddr;               //声明服务器端地址
    listenfd = socket(AF_INET, SOCK_STREAM, 0);  //创建socket
    //setnonblocking(listenfd);                  //把socket设置为非阻塞方式    
    ev.data.fd=listenfd;                         //设置与要处理的事件相关的文件描述符
    ev.events=EPOLLIN|EPOLLET;                   //设置要处理的事件类型
    //ev.events=EPOLLIN;    
 
    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);  //注册epoll事件
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char *local_addr="127.0.0.1";
    inet_aton(local_addr,&(serveraddr.sin_addr));//htons(portnumber);
    serveraddr.sin_port=htons(portnumber);
    bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
    listen(listenfd, LISTENQ);
    maxi = 0;
    for ( ; ; ) {        
        nfds=epoll_wait(epfd,events,20,500);    //等待epoll事件的发生        
        for(i=0;i<nfds;++i){                    //处理所发生的所有事件
            if(events[i].data.fd==listenfd)    //如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
            {
                connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
                if(connfd<0){
                    perror("connfd<0");
                    exit(1);
                }
                //setnonblocking(connfd);
                char *str = inet_ntoa(clientaddr.sin_addr);
                cout << "accapt a connection from " << str << endl;                
                ev.data.fd=connfd;                         //设置用于读操作的文件描述符                
                ev.events=EPOLLIN|EPOLLET;                 //设置用于注测的读操作事件
                //ev.events=EPOLLIN;                
                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);  //注册ev
            }
            else if(events[i].events&EPOLLIN)              //如果是已经连接的用户，并且收到数据，那么进行读入。
            {
                cout << "EPOLLIN" << endl;
                if ( (sockfd = events[i].data.fd) < 0)
                    continue;
                if ( (n = read(sockfd, line, MAXLINE)) < 0) {
                    if (errno == ECONNRESET) {
                        close(sockfd);
                        events[i].data.fd = -1;
                    } else
                        std::cout<<"readline error"<<std::endl;
                } else if (n == 0) {
                    close(sockfd);
                    events[i].data.fd = -1;
                }
                line[n] = '/0';
                cout << "read " << line << endl;
                
                ev.data.fd=sockfd;                           //设置用于写操作的文件描述符                
                ev.events=EPOLLOUT|EPOLLET;                  //设置用于注测的写操作事件
                //epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);  //修改sockfd上要处理的事件为EPOLLOUT
            }
            else if(events[i].events&EPOLLOUT)              // 如果有数据发送
            {
                sockfd = events[i].data.fd;
                write(sockfd, line, n);            
                ev.data.fd=sockfd;                         //设置用于读操作的文件描述符      
                ev.events=EPOLLIN|EPOLLET;                 //设置用于注测的读操作事件        
                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);  //修改sockfd上要处理的事件为EPOLIN
            }
        }
    }
    return 0;
}

参考：https://blog.csdn.net/ljx0305/article/details/4065058@TOC