epoll的事件触发模式

epoll 提供两种事件触发模式：边缘触发（Edge-Triggered, ET）和水平触发（Level-Triggered, LT）。这两种模式在处理 I/O 事件时有不同的行为。

水平触发 (Level-Triggered, LT)

水平触发是 epoll 的默认模式。其工作方式类似于传统的 select 和 poll。

• 行为：当监视的文件描述符上有数据可读或可写时，epoll_wait 会一直返回该文件描述符，直到数据被处理完毕。
• 优点：简单易用，不容易漏掉事件。适合大多数应用场景。
• 缺点：在高并发场景下，可能会导致每次 epoll_wait 调用时返回大量相同的文件描述符，降低效率。

示例代码：

#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

#define MAX_EVENTS 10

int main() {
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    struct epoll_event ev, events[MAX_EVENTS];
    int listen_sock = /* listening socket initialization */;
    ev.events = EPOLLIN | EPOLLET; // 水平触发模式，无需设置 EPOLLET
    ev.data.fd = listen_sock;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
        perror("epoll_ctl: listen_sock");
        exit(EXIT_FAILURE);
    }

    for (;;) {
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (nfds == -1) {
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }

        for (int n = 0; n < nfds; ++n) {
            if (events[n].data.fd == listen_sock) {
                // Handle new connection
            } else {
                // Handle data from a connected socket
            }
        }
    }

    close(epoll_fd);
    return 0;
}

边缘触发 (Edge-Triggered, ET)

边缘触发模式需要在 epoll_ctl 中设置 EPOLLET 标志。它只在文件描述符的状态发生变化时触发一次事件。

• 行为：只有在文件描述符状态变化（例如从不可读变为可读）时才触发事件，并且只触发一次。如果应用程序没有一次性读取所有数据，后续不会再收到该文件描述符的通知，除非状态再次变化。
• 优点：减少不必要的系统调用，适用于高性能服务器。通过减少重复通知提高效率。
• 缺点：编程更复杂，容易出现漏读或漏写的问题。需要确保每次事件处理时，读取或写入所有数据。

示例代码：

#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

#define MAX_EVENTS 10

int main() {
    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    struct epoll_event ev, events[MAX_EVENTS];
    int listen_sock = /* listening socket initialization */;
    ev.events = EPOLLIN | EPOLLET; // 边缘触发模式
    ev.data.fd = listen_sock;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
        perror("epoll_ctl: listen_sock");
        exit(EXIT_FAILURE);
    }

    for (;;) {
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (nfds == -1) {
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }

        for (int n = 0; n < nfds; ++n) {
            if (events[n].data.fd == listen_sock) {
                // Handle new connection in a non-blocking mode
                int conn_sock;
                while ((conn_sock = accept(listen_sock, NULL, NULL)) > 0) {
                    // Set conn_sock to non-blocking
                    int flags = fcntl(conn_sock, F_GETFL, 0);
                    fcntl(conn_sock, F_SETFL, flags | O_NONBLOCK);
                    ev.events = EPOLLIN | EPOLLET;
                    ev.data.fd = conn_sock;
                    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {
                        perror("epoll_ctl: conn_sock");
                        exit(EXIT_FAILURE);
                    }
                }
                if (conn_sock == -1) {
                    if (errno != EAGAIN && errno != EWOULDBLOCK) {
                        perror("accept");
                        exit(EXIT_FAILURE);
                    }
                }
            } else {
                // Handle data from a connected socket in a non-blocking mode
                int done = 0;
                while (1) {
                    ssize_t count;
                    char buf[512];
                    count = read(events[n].data.fd, buf, sizeof buf);
                    if (count == -1) {
                        if (errno != EAGAIN) {
                            perror("read");
                            done = 1;
                        }
                        break;
                    } else if (count == 0) {
                        done = 1;
                        break;
                    }

                    // Write the buffer to stdout
                    ssize_t write_count = write(1, buf, count);
                    if (write_count == -1) {
                        perror("write");
                        exit(EXIT_FAILURE);
                    }
                }

                if (done) {
                    printf("Closed connection on descriptor %d\n", events[n].data.fd);
                    close(events[n].data.fd);
                }
            }
        }
    }

    close(epoll_fd);
    return 0;
}

总结

• 水平触发 (LT)：事件会持续触发直到条件不再满足，易于使用，适合大多数情况。
• 边缘触发 (ET)：事件只在状态变化时触发，需要一次性处理所有数据，适合高性能应用，但编程复杂度较高。

选择哪种模式取决于具体应用场景和性能需求。