Linux应用开发（15）：Linux IO复用技术：epoll详细讲解

LT是默认的工作模式，对于采用LT的文件描述符，在水平触发模式下，如果某个文件描述符上有数据可读，内核会持续通知应用程序，直到应用程序处理完数据或者缓冲区不再有数据可读为止。当调用epoll_wait检测到其上有事件发生并通知应用程序时，应用程序可以不立即处理完毕该事件。这样，当程序下一次调用epoll_wait时，epoll_wait还会向应用程序通知此事件，直到事件被处理完毕

应用场景：这种机制适用于处理流式数据，如TCP连接，其中数据可能被分成多个部分到达，需要在多次epoll_wait调用之间保持对同一文件描述符的关注。，典型的如解析http报文，分次解析http报文。

（2）ET（边缘触发，EPOLLET）

只有所监听的事件状态改变或者有事件发生时，epoll_wait才会被触发.

ET比LT效率高，对于使用ET模式的文件描述符，在边缘触发模式下，只有在文件描述符状态变化（对于EPOLLIN事件，只有在状态从未就绪变化为就绪，才叫做变化）发生时才会触发事件，所以调用epoll_wait检测到其上有事件发生，并通知应用程序，应用程序必须立即处理完毕该事件，否则会造成数据丢失，因为后续的epoll_wait调用不再重复向应用程序通知此事件

应用场景：ET模式适用于处理消息队列或特定事件，因为它只在状态变化时通知，减少了不必要的事件通知，通常可以提供更高的性能。读取大型文件，用while循环一次全部读取完毕

（3）EPOLLONESHOT（一次边沿触发）

即使使用了ET模式，一个socket上的事件还是可能被触发多次。例如：当一个线程处理一个socket时有新数据写入，此时另外一个线程被唤醒读取这些数据，于是出现了两个线程同时操作一个socket的情况。EPOLLONESHOT解决了多个线程同时操作一个socket的问题，对于注册了EPOLLONESHOT的事件，操作系统最多触发其上注册的一个可读可写异常事件，且只触发一次。这样，一个线程在操作这个socket时，其他线程不可能有机会操作该socket。

注册了EPOLLONESHOT事件的socket，一旦被某个线程处理完毕，要及时修改为EPOLLIN或其他事件，以确保下次这个socket可读时，其事件能够被触发，进而让其他线程有机会继续处理。

5. EPOLLOUT

EPOLLOUT 是 Linux 系统中 epoll 事件的一种类型，用于标识文件描述符（通常是套接字）已经准备好进行写操作。当一个文件描述符缓冲区中的数据可以被成功写出时，EPOLLOUT 事件就会被触发。

EPOLLOUT与LT配合使用，满足以下两种情况时，epoll_wait会返回可写事件：

（1）当一个文件描述符准备好进行 I/O 操作时（例如，套接字的发送缓冲区有空余），它会产生一个事件。

（2）如果应用程序没有完全消费这个事件（例如，没有将发送缓冲区填满），该文件描述符仍然会持续产生事件，直到应用程序采取了适当的行动。

EPOLLOUT与ET配合使用情况比较特殊，一般是“一次性通知”，即只在可写时进行一次通知，之后不会再进行通知。如有需要，需再次进行事件的注册。

6. 当读取数据时，有新数据到来的情况。

ET模式：一个文件描述符上有数据可读（EPOLLIN触发），线程开始处理数据，而在处理过程中又有新数据加入。当旧数据开始处理时，文件描述符仍然保持在就绪状态。但当有新的数据写入时，文件描述符会从就绪状态变为未就绪状态，然后再次变为就绪状态，触发一次新的 EPOLLIN 事件。这样可以确保即使在旧数据处理过程中有新的数据写入，应用程序也能及时地得到通知，并读取新的数据。在单线程上，此时只要程序循环读取数据就不会造成新数据的丢失，而对于多线程就需要特殊处理（详见下EPOLLONESHOT）

LT 模式：新数据的写入不会改变文件描述符的状态码。如果文件描述符上有数据可读，它的状态码会一直保持就绪状态，直到所有的数据都被读取完毕才会变为未就绪。即使在读取数据的过程中有新的数据写入，文件描述符的状态码仍然会保持就绪状态，不会因为新数据的写入而改变。

7. 使用过程中的若干问题

（1）为什么一般要配合非阻塞使用？

一般情况下，ET强烈建议使用非阻塞，LT则不强制使用。

当缓冲区中的数据不足以满足一次read调用时，read调用会阻塞，导致应用程序无法继续处理其他I/O事件，甚至可能错过重要数据。

（2）什么情况下，LT可以配合阻塞I/O？

当应用程序需要处理大量数据或流式数据时（如TCP连接中的数据流），水平触发模式可以持续通知应用程序文件描述符上的可读或可写事件，直到所有相关事件都被处理完毕。在这种情况下，即使使用阻塞I/O，应用程序也可以在处理完当前文件描述符上的事件后，继续处理下一个就绪的文件描述符，因为epoll会确保只要事件就绪，就会持续通知。

虽然水平触发模式可以配合阻塞I/O使用，但在某些情况下，使用非阻塞I/O可能会获得更好的性能。非阻塞I/O允许应用程序在等待I/O操作完成时继续执行其他任务，从而提高并发性能。

8. 应用场景

简单讲就是按照小流大块来划分。

小流，即小数据包，流式传输，推荐使用LT触发模式。

大块，大数据量，块式传输，推荐使用ET触发模式。

（1）水平触发（Level-Triggered，LT）场景介绍：

水平触发模式适用于需要确保数据完整性和处理少量数据的场景。在这种模式下，只要文件描述符上的事件（如可读、可写）处于就绪状态，epoll就会持续通知应用程序，直到该事件被处理完毕。这种机制特别适合于处理流式数据，如TCP连接中的数据流，因为数据可能会分多个部分到达，需要在多次epoll_wait调用之间保持对同一文件描述符的关注。

详细介绍

持续通知：在LT模式下，只要文件描述符上的事件就绪，epoll就会持续通知应用程序，即使事件未被完全处理。这确保了应用程序有足够的机会来读取或写入数据，从而避免数据丢失。

适用于流式数据：由于TCP连接中的数据是以流的形式传输的，可能会分多个TCP包到达，因此LT模式非常适合于处理这种情况。应用程序可以在多次epoll_wait调用中逐步读取数据，直到整个消息被完整接收。

可能的问题：如果应用程序在处理事件时不够高效，可能会导致epoll事件队列中积压大量事件，进而影响性能。此外，如果文件描述符一直处于就绪状态（如对方持续发送数据），epoll将不断通知应用程序，这可能会浪费CPU资源。

（2）边沿触发（Edge-Triggered，ET）场景介绍：

边沿触发模式适用于高并发、高吞吐量的场景，特别是当需要精确控制事件通知次数时。在这种模式下，epoll只在文件描述符的状态发生变化时通知应用程序一次。这要求应用程序在收到通知后必须尽可能多地处理数据，因为下次通知可能不会到来，除非有新的状态变化发生。

详细介绍

单次通知：在ET模式下，epoll只在文件描述符的状态从不可读变为可读（或从不可写变为可写）时通知应用程序一次。如果应用程序没有在一次通知中处理完所有数据，它需要在下次epoll_wait调用之前继续处理剩余的数据，因为下次通知可能不会到来。

高性能：由于ET模式减少了不必要的通知次数，因此可以显著提高应用程序的性能和吞吐量。它特别适合于需要处理大量并发连接的场景，如Web服务器、数据库服务器等。

编程复杂性：然而，ET模式也增加了编程的复杂性。应用程序需要确保在收到通知后能够尽可能多地处理数据，并且需要妥善处理数据残留问题（即在一次通知中未处理完的数据）。此外，ET模式通常与非阻塞I/O结合使用，以进一步提高性能。

（3）流媒体应用场景下，如何选择触发方式？

一般情况下可以这样设定，传输指令使用ET模式，传输流数据使用LT模式。

9. 例程

#include <sys/socket.h> //for socket
#include <arpa/inet.h>  //for htonl htons
#include <sys/epoll.h>  //for epoll_ctl
#include <unistd.h>     //for close
#include <fcntl.h>      //for fcntl
#include <errno.h>      //for errno
#include <iostream>     //for cout

class fd_object
{
public:
    fd_object(int fd) { listen_fd = fd; }
    ~fd_object() { close(listen_fd); }
private:
    int listen_fd;
};


int main(int argc, char* argv[])
{
    /** 创建socket. */
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1){
        std::cout << "Create socket failed." << std::endl;
        return -1;
    }
    fd_object obj(listen_fd);

    /** 设置为非阻塞. */
    int socket_flag = fcntl(listen_fd, F_GETFL, 0);
    socket_flag |= O_NONBLOCK;
    if (fcntl(listen_fd, F_SETFL, socket_flag) == -1)
    {
        std::cout << "Set listen fd to nonblock failed." << std::endl;
        return -1;
    }

    /** Bind。 */
    int port = 51741;
    struct sockaddr_in bind_addr;
    bind_addr.sin_family = AF_INET;
    bind_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind_addr.sin_port = htons(port);
    if (bind(listen_fd, (struct sockaddr *)&bind_addr, sizeof(bind_addr)) == -1){
        std::cout << "Bind socket fd failed." << std::endl;
        return -1;
    }

    /** Listen。 */
    if (listen(listen_fd, SOMAXCONN) == -1){
        std::cout << "Listen error." << std::endl;
        return -1;
    }else{
        std::cout << "Start server at port [" << port << "] with [" << (argc <= 1 ? "LT" : "ET") << "] mode." << std::endl;
    }

    /** 创建Epoll. */
    int epoll_fd = epoll_create(88);
    if (epoll_fd == -1)
    {
        std::cout << "Create epoll." << std::endl;
        return -1;
    }

    /** 添加Epoll事件. */
    epoll_event listen_fd_event;
    listen_fd_event.data.fd = listen_fd;
    listen_fd_event.events = EPOLLIN;
    if (argc > 1) listen_fd_event.events |= EPOLLET;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &listen_fd_event) == -1){
        std::cout << "Add epoll event failed." << std::endl;
        return -1;
    }

    /** 循环处理. */
    while (true){
        epoll_event epoll_events[1024]; ///< 最多收集1024个epoll事件.
        int n = epoll_wait(epoll_fd, epoll_events, 1024, 1000);
        if (n < 0)
            break;
        else if (n == 0) ///< 超时，没有捕获事件
            continue;

        for (int i = 0; i < n; ++i) ///< 依次处理事件.
        {
            if (epoll_events[i].events & EPOLLIN)//trigger read event
            {
                if (epoll_events[i].data.fd == listen_fd){
                    /** 服务端可读事件. */
                    /** 接受新连接. */
                    struct sockaddr_in client_addr;
                    socklen_t client_addr_len = sizeof(client_addr);
                    int client_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_addr_len);
                    if (client_fd == -1)
                        continue;

                    socket_flag = fcntl(client_fd, F_GETFL, 0);
                    socket_flag |= O_NONBLOCK;
                    if (fcntl(client_fd, F_SETFL, socket_flag) == -1){
                        close(client_fd);
                        std::cout << "Set client fd to non-block failed." << std::endl;
                        continue;
                    }

                    /** 注册客户端fd的可读、可写事件. */
                    epoll_event client_fd_event;
                    client_fd_event.data.fd = client_fd;
                    client_fd_event.events = EPOLLIN | EPOLLOUT;
                    if (argc > 1) client_fd_event.events |= EPOLLET;

                    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &client_fd_event) == -1){
                        std::cout << "Add client epoll event(r/w) failed." << std::endl;
                        close(client_fd);
                        continue;
                    }
                    std::cout << "Accept a new client fd [" << client_fd << "]." << std::endl;
                }else{
                    /** 客户端可读事件. */
                    std::cout << "Client EPOLLIN event triggered, fd [" << epoll_events[i].data.fd << "]." << std::endl;
                    char recvbuf[1024] = { 0 };
                    int m = recv(epoll_events[i].data.fd, recvbuf, 1, 0); // only read 1 bytes when read event triggered
                    if (m == 0 || (m < 0 && errno != EWOULDBLOCK && errno != EINTR)){
                        if (epoll_ctl(epoll_fd, EPOLL_CTL_DEL, epoll_events[i].data.fd, NULL) != -1)
                            std::cout << "the client fd [" << epoll_events[i].data.fd << "] disconnected." <<  std::endl;
                        close(epoll_events[i].data.fd);
                    }
                    std::cout << "Recv data from client fd [" << epoll_events[i].data.fd << "] and data is [" << recvbuf << "]." << std::endl;
                }
            }else if (epoll_events[i].events & EPOLLOUT){
                if (epoll_events[i].data.fd == listen_fd) /// 不处理监听fd的写操作
                    continue;
                /** 客户端可写事件. */
                std::cout << "Client EPOLLOUT event triggered, fd [" << epoll_events[i].data.fd << "]." << std::endl;
            }
        }
    }

    return 0;
}