【I/O复用】epoll系统调用（1）

参考《Linux高性能服务器编程》

介绍

epoll是Linux特有的I/O复用函数，允许把文件描述符上的事件放在内核的一个事件表中。当事件表检测到就绪事件后，就可以对它们进行处理。

内核事件表

epoll需要使用一个额外的文件描述符，来唯一标识内核中的这个事件表。这个文件描述符用如下函数创建：

#include <sys/epoll.h>

// size参数现在不起作用，它只是给内核一个提示，告诉事件表需要多大。
// 该函数返回的文件描述符将用作其他所有epoll系统调用的第一个参数，以指定要访问的内核事件表
int epoll_create(int size);

下面的函数用来操作epoll的内核事件表:

#include <sys/epoll.h>

// 成功时返回0，失败时返回-1
int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event);

fd参数是要操作的文件描述符，op参数指定操作类型。操作类型主要有三种：

• EPOLL_CTL_ADD，往事件表中注册fd上的事件
• EPOLL_CTL_MOD，修改fd上的注册事件
• EPOLL_CTL_DEL，删除fd上的注册事件

event参数指定事件，结构体如下：

struct epoll_event {
  __uint32_t events;  // epoll事件
  epoll_data_t data;  // 用户数据
};

events成员描述事件类型，epoll支持的事件类型和poll基本相同，表示epoll事件的宏是在poll对应的宏前面加上E。但是epoll有两个额外的事件：EPOLLET, EPOLLONESHOT，它们对epoll的高效运作非常关键。

事件	描述	是否可做为输入	是否可做为输出
EPOLLIN	数据(包括普通数据和优先数据)可读	是	是
EPOLLRDNORM	普通数据可读	是	是
EPOLLRDBAND	优先级带数据可读(Linux 不支持)	是	是
EPOLLPRI	高优先级数据可读，比如 TCP 带外数据	是	是
EPOLLOUT	数据(包括普通数据和优先数据）可写	是	是
EPOLLWRNORM	普通数据可写	是	是
EPOLLWRBAND	优先级带数据可写	是	是
EPOLLRDHUP	TCP 连接被对方关闭，或者对方关闭了写操作。它由GNU 引人	是	是
EPOLLERR	错误	否	是
EPOLLHUP	挂起。比如管道的写端被关闭后，读端描述符上将收到 POLLHUP事件	否	是
EPOLLNVAL	文件描述符没有打开	否	是

data成员用于存储用户数据，其类型定义如下。由于union一次只能使用一个数据，因此一般使用ptr，并且在指向的用户数据中包含fd。

typedef union epoll_data {
  	void* ptr;        // 指定与fd相关的用户数据
    int fd;           // 指定事件从属的目标文件描述符
    uint32_t u32;     // 
    uint32_t u64;
}epoll_data_t;

epoll_wait函数

epoll系列系统调用的主要接口是epoll_wait函数。它在一段时间内等待一组文件描述符上的事件。

#include <sys/epoll.h>

// 成功时返回就绪的文件描述符个数，失败时返回-1
int epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout);

epoll_wait函数如果检测到事件，就将所有的就绪事件从内核事件表epfd中复制到它的第二个参数events指向的数组中。这个数组只用于输出就绪事件。下面代码展示了如何使用这个函数：

// 如何索引epoll返回的文件描述符就绪个数
int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);

// 遍历就绪的文件描述符
for (int i = 0; i < ret; i ++) {
    int sockfd = events[i].data.fd;
    // sockfd肯定就绪，直接处理
}

LT和ET模式

epoll对文件描述符的操作有两种模式: LT(Level Trigger，电平触发)模式和 ET(Edge Trigger，边沿触发)模式。LT 模式是默认的工作模式，这种模式下 epoll相当于一个效率较高的 poll。当往 epoll 内核事件表中注册一个文件描述符上的 EPOLLET 事件时，epoll将以ET模式来操作该文件描述符。ET模式是 poll 的高效工作模式。
对于采用 LT 工作模式的文件描述符，当 epoll_wait 检测到其上有事件发生并将此事件通知应用程序后，应用程序可以不立即处理该事件。这样，当应用程序下一次调用epoll_wait 时，epoll_wait 还会再次向应用程序通告此事件，直到该事件被处理。而对于采用 ET 工作模式的文件描述符，当 epoll wait 检测到其上有事件发生并将此事件通知应用程序后，应用程序必须立即处理该事件，因为后续的 epoll wait 调用将不再向应用程序通知这一事件。可见，ET 模式在很大程度上降低了同一个 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。

需要注意的是，每个使用ET模式的文件描述符都应该是非阻塞的。如果文件描述符是阻塞的，那么读或者写操作会因为没有后续的事件而一直处于阻塞状态。

下面使用代码来理解这两种模式的工作方式。

测试LT和ET模式

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <assert.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <pthread.h>

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10

/*将文件描述符设置为非阻塞的*/
int setnonblocking(int fd) {
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);

    return old_option;
}

/*将文件描述符fd上EPOLLIN注册到epollfd指示的内核事件表中，参数enable_et指定是否对fd启用et模式*/
void addfd(int epollfd, int fd, bool enable_et) {
    epoll_event event;
    event.data.fd = fd;
    // 数据可读
    event.events = EPOLLIN;

    if (enable_et) {
        event.events |= EPOLLET;
    }
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    // 文件描述符设置为非阻塞的
    setnonblocking(fd);
}


/*lt模式工作流程*/

void lt(epoll_event* events, int number, int epollfd, int listen_socket) {
    printf("event number: %d\n", number);
    char buf[BUFFER_SIZE];
    // 处理每一个事件
    for (int i = 0; i < number; i++) {

        int sockfd = events[i].data.fd;

        // 按理来说全都是监听socket的事件
        if (sockfd == listen_socket) {
            // 连接到客户端
            printf("new client\n");
            struct sockaddr_in client_addr;
            socklen_t client_addrlen = sizeof(client_addr);

            int connfd = accept(listen_socket, (sockaddr*)&client_addr, &client_addrlen);

            // 对通信socket禁用et模式，为什么？
            addfd(epollfd, connfd, false);
        }
        else if (events[i].events & EPOLLIN) {
            /*只要socket读缓存中还有未读出的数据，这段代码就被触发*/

            printf("event trigger once\n");
            memset(buf, '\0', BUFFER_SIZE);

            // 读取数据
            int ret = recv(sockfd, buf, BUFFER_SIZE - 1, 0);
            if (ret <= 0) {
                close(sockfd);
                continue;
            }

            printf("get %d bytes of content: %s\n", ret, buf);
        }
        else {
            printf("something else happened\n");
        }
    }
}


/*et模式工作流程*/

void et(epoll_event* events, int number, int epollfd, int listen_socket) {
    printf("event number: %d\n", number);
    char buf[BUFFER_SIZE];
    // 处理每一个事件
    for (int i = 0; i < number; i++) {

        int sockfd = events[i].data.fd;

        // 按理来说全都是监听socket的事件
        if (sockfd == listen_socket) {
            // 连接到客户端
            printf("new client\n");
            struct sockaddr_in client_addr;
            socklen_t client_addrlen = sizeof(client_addr);

            int connfd = accept(listen_socket, (sockaddr*)&client_addr, &client_addrlen);

            // 对通信socket开启et模式
            addfd(epollfd, connfd, true);
        }
        else if (events[i].events & EPOLLIN) {
            /*这段代码不会重复触发，所以我们要循环读取数据，确保把socket读缓冲区的所有数据读出*/
            printf("event trigger once\n");
            
            while (1) {
                memset(buf, '\0', BUFFER_SIZE);
            
                // 读取数据
                int ret = recv(sockfd, buf, BUFFER_SIZE - 1, 0);
                if (ret < 0) {
                    /*对于非阻塞IO，下面的条件成立表示数据全部读取完毕，此后epoll可以再次触发sockfd上的EPOLLIN事件*/
                    if (errno == EAGAIN || errno == EWOULDBLOCK) {
                        printf("read later\n");
                        break;
                    }
                    close(sockfd);
                    break;
                }
                else if (ret == 0) {
                    close(sockfd);
                    break;
                }
                else {
                    printf("get %d bytes of content: %s\n", ret, buf);
                }
            }
        }
        else {
            printf("something else happened\n");
        }
    }
}



int main()
{
    // 监听socket的ip和端口
    const char ip[] = "192.168.91.128";
    short port = 12345;
    int ret = 0;


    // 创建监听socket地址
    sockaddr_in address;
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    // 创建监听socket
    int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
    assert(listen_socket >= 0);

    // 监听socket绑定到地址
    ret = bind(listen_socket, (sockaddr*)&address, sizeof(address));
    assert(ret != -1);

    // 开始监听
    ret = listen(listen_socket, 5);
    assert(ret != -1);


    printf("[Server] listen\n");

    // 创建事件列表
    epoll_event events[MAX_EVENT_NUMBER];
    // 返回事件表的fd
    int epollfd = epoll_create(5);
    assert(epollfd != -1);

    // 为什么要把监听socket设置成et？也就是立即处理到来的事件（）？并且还设置成非阻塞
    addfd(epollfd, listen_socket, true);

    while (1) {
        // 阻塞，不设置超时
        printf("[Server] epoll wait start\n");
        ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        printf("[Server] epoll wait end\n");

        if (ret < 0) {
            printf("epoll failure\n");
            break;
        }

        //lt(events, ret, epollfd, listen_socket);   // 使用lt模式
        et(events, ret, epollfd, listen_socket);   // 使用et模式
    }

    close(listen_socket);
    getchar();
    return 0;
}

这份代码是服务端代码，与之前的代码不同，这里把监听socket放入了epoll事件表中，并且设置了ET模式、非阻塞，在while循环中监听。一旦有客户端建立连接，epoll_wait函数就会返回，并进入lt函数或者et函数。

lt函数的处理逻辑是：

• 遍历每个事件的文件描述符，如果是监听socket，说明有新的客户端建立了连接，因此调用accept建立通信socket。并且把通信socket设置成LT模式、非阻塞，添加到epoll事件表中
• 如果不是监听socket，那就是某个与客户端连接的通信socket收到了消息，因此调用recv读取定量大小的数据。

et函数的流程是：

• 遍历每个事件的文件描述符，如果是监听socket，说明有新的客户端建立了连接，因此调用accept建立通信socket。并且把通信socket设置成ET模式、非阻塞，添加到epoll事件表中
• 如果不是监听socket，那就是某个与客户端连接的通信socket收到了消息，因此调用recv读取定量大小的数据。注意这里不一样的地方是，循环读取全部的客户端数据。

首先设置使用lt函数，运行服务器，在Linux终端使用telnet连接服务器，发送一个大小超过10字节的数据。

服务器输出的内容：

[Server] listen
[Server] epoll wait start
[Server] epoll wait end
event number: 1
new client
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 9 bytes of content: this is a
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 9 bytes of content: message
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 9 bytes of content: from clie
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 5 bytes of content: nt!
[Server] epoll wait start

可以看到，客户端发送的数据是“this is a message from client!”，但是服务端一次只能读取9字节的数据。结果就是epoll_wait发现通信socket事件就绪后，退出阻塞，调用lt函数处理事件；第一次读取了9字节的数据"this is a"之后，退出lt函数，再次进入epoll_wait函数阻塞；而由于通信socket设置成LT模式，epoll_wait马上发现通信socket还有缓存数据没有处理，因此退出阻塞，调用lt函数；第二次又读取了"message"这个字符串。
就这样，设置成LT模式的通信socket的事件被epoll_wait函数通告了4次，才完整地读取所有客户端数据。

然后我们再使用et函数，客户端发送同样的数据，服务端输出情况如下：

[Server] listen
[Server] epoll wait start
[Server] epoll wait end
event number: 1
new client
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 9 bytes of content: this is a
get 9 bytes of content: message
get 9 bytes of content: from clie
get 5 bytes of content: nt!
read later
[Server] epoll wait start

可以看到，epoll_wait函数检测到通信socket就绪后，退出阻塞，进入到et函数，循环读取数据，一次性全部读取完。因此ET模式比LT模式效率要高。

关于ET与LT模式的解释

有人可能会觉得疑惑，看了代码之后，好像lt函数和et函数的区别只是循环读取通信socket，如果在lt函数中也设置循环读取，那不是和et函数效果一样吗？ET模式的意义在哪里？

其实不是的，ET模式的意义就在于，epoll_wait函数对于ET模式文件描述符的就绪事件，只会通告一次，所以相当于强行给应用程序规定：我这个ET模式文件描述符的事件，你必须给我立刻处理完！下次我就不提醒你了！。

如果还是不能理解，可以这样进行测试：在et函数中，把通信socket事件处理逻辑从循环读取改成读取一次。客户端发送同样的数据，看看服务端的输出：

[Server] listen
[Server] epoll wait start
[Server] epoll wait end
event number: 1
new client
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 9 bytes of content: this is a
[Server] epoll wait start

为什么只读取了“this is a”这个字符串？其他的字符串哪里去了？
我们尝试在客户端继续发送一些字节，比如我很现在疑惑，发送了一个“why?”：

此时服务端的输出：

[Server] listen
[Server] epoll wait start
[Server] epoll wait end
event number: 1
new client
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 9 bytes of content: this is a
[Server] epoll wait start
[Server] epoll wait end
event number: 1
event trigger once
get 9 bytes of content: message
[Server] epoll wait start

服务端又接收到了"message"这个字符串。现在我们就知道为什么了，因为ET模式的文件描述符的事件，epoll_wait只会通告一次，如果应用程序不遵守规则，没有老老实实读取全部的数据，那么剩下的数据保留在缓存中。除非客户端又发送了数据，epoll_wait收到了这个事件，才会再次通告应用程序去处理。而这样的话，应用程序就会一直滞后接收消息。

总结

epoll系统调用可以为文件描述符设置EPOLLET模式，相关事件只会被通告一次，所以应用程序必须立即处理这个事件。EPOLLET是epoll高效的原因之一。

下面还有一个问题，我在测试的时候遇到并且记录下来：

为什么通信socket需要设置为非阻塞？
答：如果设置成阻塞，那么在recv会一直阻塞，无法实现服务端与多个客户端通信。一般来说要实现多客户端通信，需要创建子进程。使用epoll就不需要创建子进程，很方便。