epoll服务器---I/O多路转接之epoll

1、基本知识

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

2、epoll接口

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

• epoll_create:
  　　

创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

• epoll_ctl:
  　　

epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：

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

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

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

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

其中epoll_data_t是一个联合体，定义如下：

• epoll_wait
  

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

3.epoll的工作模式

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.epoll的底层实现

在调用epoll_create时操作系统会创建一颗红黑树存放socket和一个队列存放就绪事件

由上面我们知道epoll是由三个函数接口实现，epoll_create创建了一个句柄，管理关心的文件fd，底层epoll_create创建了一棵空的红黑树(高效)和一个空的消息队列，红黑树的key值为文件的fd,value为该文件的关心的事件（读或写）；epoll_ctl用来注册要监听的事件类型，在底层，当events为EPOLL_CTL_ADD它将监听的事件作为一个新的节点插入到红黑树中，EPOLL_CTL_MOD找到对应的节点修改该节点的value值，EPOLL_CTL_DEL找到对应节点并从红黑树中删除该节点。epoll_wait用来等待事件的就绪，一旦有事件就绪，就从红黑树找到该就绪事件的节点，拷贝它到队列中，该队列我也就是我们定义的struct epoll_event resv[max_size]数组，我们在处理就绪事件时，直接从队列中获取（就绪事件有序）

5.epoll服务器的编写

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/select.h>
#include<string.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<unistd.h>


#define M 64

//提示打印信息
static void usage(const char* proc)
{
    printf("usage:%s [local_ip] [local_port]\n",proc);
}

//创建套接字
int startup(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);
    local.sin_addr.s_addr = inet_addr(ip);

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

    if(listen(sock,10)<0){
        perror("listen");
        exit(4);
    }
    return sock;
}

int main(int argc,char* argv[])
{
    if(argc!=3){
        usage(argv[0]);
        return 1;
    }

    int listen_sock = startup(argv[1],atoi(argv[2]));

   //创建句柄
    int ep_fd = epoll_create(256);
    if(ep_fd<0){
        perror("epoll_create");
        exit(5);
    }

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

   //将listen_sock的读事件加入到句柄中
    if(epoll_ctl(ep_fd,EPOLL_CTL_ADD,listen_sock,&ev)<0){
        perror("epoll_ctl");
        exit(6);    
    }

    int timeout = 10000;
    int nums = -1;//就绪事件的个数
    int maxevent = M;
    struct epoll_event array[M];

    while(1){

    //等待就绪事件数组中的数组就绪
    nums = epoll_wait(ep_fd,array,maxevent,timeout);

    switch(nums){
        case -1:
            perror("epoll_wait");//epoll_wait出错
            break;
        case 0:
            printf("timeout...\n");//超时
            break;
        default:
            {
                int i=0;
                for(;i<nums;++i){//遍历就绪事件
                    if(array[i].data.fd==listen_sock && array[i].events & EPOLLIN){//listen_sock的读事件
                        struct sockaddr_in client;
                        socklen_t len = sizeof(client);
                        //创建new_sock
                        int new_sock = accept(listen_sock,\
                                (struct sockaddr*)&client,&len);
                        if(new_sock<0){
                            perror("accept");
                            exit(7);
                        }
                        //建立客户端的连接
                        printf("get a new client:[%s:%d]\n",inet_ntoa(client.sin_addr),\
                                                              ntohs(client.sin_port));
                        //listen_sock的读事件完成后，此时客户端可以向客户端写数据，将关心的写时间加入句柄中
                            struct epoll_event event;
                            event.events = EPOLLIN;
                            event.data.fd = new_sock;
                            epoll_ctl(ep_fd,EPOLL_CTL_ADD,new_sock,&event);
                    }else if(array[i].data.fd != listen_sock){//普通事件
                        if(array[i].events & EPOLLIN)//读就绪{//read ready
                            int buf[1024];
                            ssize_t s = read(array[i].data.fd,buf,sizeof(buf)-1);//BUG!!!
                            if(s<0){
                                perror("read");
                                close(array[i].data.fd);
                                epoll_ctl(ep_fd,EPOLL_CTL_DEL,array[i].data.fd,0);
                                exit(8);
                            }else if(s==0){
                                printf("clilent is quit\n");
                                close(array[i].data.fd);
                                epoll_ctl(ep_fd,EPOLL_CTL_DEL,array[i].data.fd,0);//读取失败，删除该事件的读
                            }else{
                                buf[s] = 0;
                                printf("client#:%s\n",buf);
                                array[i].events = EPOLLOUT; 

//读取成功，将该时间再改为写                             epoll_ctl(ep_fd,EPOLL_CTL_MOD,\
                                          array[i].data.fd,&array[i]);
                            }
                        }else if(array[i].events & EPOLLOUT){//write ready写事件就绪
                            //char msg[1024];
                            const char* msg = "HTTP/1.0 OK 200\r\n\r\n\
                                               <html><ht>hello workd</ht></html>";//向网页输出hello world

                        //实现和客户端的读写通信
                        //  int r = read(0,msg,sizeof(msg)-1);//和客户端通信时，从标准输入上读数据

                        //  if(r<0){
                        //      perror("read");
                        //      close(ready_array[i].data.fd);
                        //      epoll_ctl(ep_fd,EPOLL_CTL_DEL,ready_array[i].data.fd,0);
                        //  }else{
    //写数据                           write(array[i].data.fd,msg,strlen(msg));
                                array[i].events = EPOLLIN;
                                epoll_ctl(ep_fd,EPOLL_CTL_MOD,\
                                          array[i].data.fd,&array[i]);
                        //  }
                        }else{//other ready
                        }
                    }else{//
                    }
                }
            }
    }//wswitch
    }//while
    return 0;
}

客户端代码：

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/select.h>
#include<string.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<unistd.h>


static void usage(const char* proc)
{
    printf("usage:%s [local_ip] [local_port]\n",proc);
}

int main(int argc,char* argv[]){
    if(argc!=3){
        usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET,SOCK_STREAM,0);

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    if(connect(sock,(struct sockaddr*)&server,sizeof(server))<0){
        perror("connect");
        return 2;
    }

    while(1){
        char buf[1024];
        printf("Please Enter:");
        fflush(stdout);
        read(0,buf,sizeof(buf)-1);
        write(sock,buf,strlen(buf));
        ssize_t s = read(sock,buf,sizeof(buf)-1);
        if(s<0){
            perror("read");
            return 3;
        }else if(s==0){
            close(sock);
            break;
        }else{
            buf[s]=0;
            printf("server say#:%s",buf);
        }
    }

    return 0;
}

结果图：

6.epoll服务器的优点

优点
（1）支持一个进程打开大数目的socket描述符(FD)
（2）IO效率不随fd数目增加而线性下降
（3）使用mmap加速内核与用户空间的消息传递。