十二 优于select的epoll

基于select的I/O复用技术速度慢的原因：

调用select函数后常见的针对所有文件描述符的循环语句。

每次调用select函数后都需要向该函数传递监视对象信息。

epoll函数的优点正好与select缺点相反：

无需编写以监视状态变化为目的的针对所有文件描述符的循环语句。

调用对应于select函数的epoll-wait函数时无需每次传递监视对象信息。

实现epoll时必要的函数：

epoll_create:创建保存epoll文件描述符的空间。

epoll_ctl：向空间注册或销毁文件描述符。

epoll_wait：与select函数类似，等待文件描述符发生变化。

声明足够大的epoll_event结构体数组后，传递给epoll_wait函数时，发生变化的文件描述符信息将被填入该数组。

因此，无需像select函数那样针对所有文件描述符进行循环。

基于epoll的回声服务器端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>

#define BUF_SIZE 100
#define EPOLL_SIZE 50
void error_handling(char *buf);

int main(int argc, const char * argv[]) {
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    socklen_t adr_sz;
    int str_len, i;
    char buf[BUF_SIZE];

    //类似select的fd_set变量查看监视对象的状态变化，epoll_event结构体将发生变化的文件描述符单独集中到一起
    struct epoll_event *ep_events;
    struct epoll_event event;
    int epfd, event_cnt;

    if(argc != 2)
    {
        printf("Usage: %s <port> \n", argv[0]);
        exit(1);
    }

    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if(serv_sock == -1)
        error_handling("socket() error");

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    if(bind(serv_sock, (struct sockaddr *) &serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");

    if(listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    //创建文件描述符的保存空间称为“epoll例程”
    epfd = epoll_create(EPOLL_SIZE);
    ep_events = malloc(sizeof(struct epoll_event) *EPOLL_SIZE);

    //添加读取事件的监视(注册事件)
    event.events = EPOLLIN;  //读取数据事件
    event.data.fd = serv_sock;
    epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);

    while (1)
    {
        //响应事件，返回发生事件的文件描述符数
        event_cnt = epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);  //传-1时，一直等待直到事件发生
        if(event_cnt == -1)
        {
            puts("epoll_wait() error");
            break;
        }

        //服务端套接字和客服端套接字
        for (i = 0; i < event_cnt; i++) {
            if(ep_events[i].data.fd == serv_sock)//服务端与客服端建立连接
            {
                adr_sz = sizeof(clnt_adr);
                clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &adr_sz);
                event.events = EPOLLIN;
                event.data.fd = clnt_sock;
                epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
                printf("connected client: %d \n", clnt_sock);
            }
            else  //连接之后传递数据
            {
                str_len = read(ep_events[i].data.fd, buf, BUF_SIZE);
                if(str_len == 0)
                {
                    //删除事件
                    epoll_ctl(epfd, EPOLL_CTL_DEL, ep_events[i].data.fd, NULL);
                    close(ep_events[i].data.fd);
                    printf("closed client: %d \n", ep_events[i].data.fd);
                }
                else
                {
                    write(ep_events[i].data.fd, buf, str_len);
                }
            }
        }
    }

    close(serv_sock);
    close(epfd);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

条件触发和边缘触发

条件触法方式中,只要输入缓冲中还剩有数据,就将以事件方式再次注册.epoll默认使用该方式.

边缘触发中输入缓冲收到数据时仅注册一次事件,即使输入缓冲中还留有数据,也不会再进行注册.

实现边缘触发的回声服务器端

1.边缘触发方式中,接收数据时仅注册一次该事件,因此,一旦发生输入相关事件,就应该读取输入缓冲中的全部数据.

    因此需要验证输入缓冲是否为空.

                read函数返回-1,变量error中的值为EAGAIN时,说明没有数据可读.

2..边缘触发方式下,以阻塞方式工作的read和write函数有可能引起服务器端的长时间停顿,所以需要将套接字变成非阻塞模式.

    #include<stdio.h>  
    #include<stdlib.h>  
    #include<string.h>  
    #include<unistd.h>  
    #include<arpa/inet.h>  
    #include<sys/socket.h>  
    #include<sys/epoll.h>  
    #include<fcntl.h>  
    #include<errno.h>  
    #define BUF_SIZE 4          //验证边缘触发的工作方式，将缓冲设置为4字节  
    #define EPOLL_SIZE 50  
    void error_handling(char *message);  
    void setnonblockingmode(int fd);  
      
    int main(int argc, char *argv[])  
    {  
        int serv_sock, clnt_sock;  
        struct sockaddr_in serv_adr, clnt_adr;  
        socklen_t adr_sz;  
        int str_len, i;  
        char buf[BUF_SIZE];  
          
        struct epoll_event *ep_events;  
        struct epoll_event event;  
        int epfd, event_cnt;  
      
        if (argc != 2)  
        {  
            printf("Usage: %s <port> \n",argv[0]);  
            exit(1);  
        }  
      
        serv_sock = socket(PF_INET,SOCK_STREAM,0);  
        memset(&serv_adr,0,sizeof(serv_adr));  
        serv_adr.sin_family = AF_INET;  
        serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);  
        serv_adr.sin_port = htons(atoi(argv[1]));  
      
        if (bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr)) == -1)  
            error_handling("bind() error!");  
        if (listen(serv_sock,5) == -1)  
            error_handling("listen() error!");  
      
        epfd = epoll_create(EPOLL_SIZE);        //创建epoll例程文件描述符  
        ep_events = malloc(sizeof(struct epoll_event) * EPOLL_SIZE);  
      
        setnonblockingmode(serv_sock);  
        event.events = EPOLLIN;  
        event.data.fd = serv_sock;  
        epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);  //在epfd内注册监视serv__sock,监视其读取数据的情况  
      
        while(1)  
        {  
            event_cnt = epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);    //成功返回发生事件的文件描述符数。失败返回-1.发生事件的文件描述符保存到events所指的结构体中  
            if (event_cnt == -1)  
            {  
                puts("epoll_wait() error!");  
                break;  
            }  
              
            puts("return epoll_wait");  
            for (i = 0; i < event_cnt; i++)        
            {  
                if (ep_events[i].data.fd == serv_sock)  //服务器端套接字接收连接  
                {  
                    adr_sz = sizeof(clnt_adr);  
                    clnt_sock = accept(serv_sock,(struct sockaddr*)&clnt_adr,&adr_sz);  
                    setnonblockingmode(clnt_sock);          //改为非阻塞  
                    event.events = EPOLLIN | EPOLLET;       //套接字事件注册方式改为边缘触发  
                    event.data.fd = clnt_sock;  
                    epoll_ctl(epfd,EPOLL_CTL_ADD,clnt_sock,&event); //注册监视连接客户端套接字clnt_sock,监视其读取数据的情况   
                    printf("connected client: %d \n",clnt_sock);  
                }  
                else            //连接客户端套接字读取数据  
                {  
                    while(1)    //边缘触发发生事件时，需要读取输入缓冲中的所有数据，因此需要循环调用read函数  
                    {  
                        str_len = read(ep_events[i].data.fd, buf, BUF_SIZE);  
                        if (str_len == 0)       //close request  
                        {  
                            epoll_ctl(epfd,EPOLL_CTL_DEL,ep_events[i].data.fd,NULL);  
                            close(ep_events[i].data.fd);  
                            printf("closed client: %d \n",ep_events[i].data.fd);  
                            break;  
                        }  
                        else if(str_len < 0) {  
                            if (errno == EAGAIN)  
                                break;  
                        }  
                        else   
                        {  
                            write(ep_events[i].data.fd, buf, str_len);  //echo!  
                        }  
                    }  
                }  
            }  
        }  
        close(serv_sock);  
        close(epfd);  
        return 0;  
    }  
      
    void setnonblockingmode(int fd)  
    {  
        int flag = fcntl(fd,F_GETFL,0);  
        fcntl(fd,F_SETFL,flag|O_NONBLOCK);  
    }  
      
    void error_handling(char *message)  
    {  
        fputs(message,stderr);  
        fputc('\n',stderr);  
        exit(1);  
    }  

从实现模型的角度看,边缘触发更有可能带来高性能,但不能简单地认为”只要使用边缘触发就一定能提高速度”.