操作系统 / 系统课时

实现 epoll 事件循环主干

实现 epoll 事件循环主干

这一节把监听套接字、非阻塞 accept、epoll 事件分发和连接对象收束到一个可运行主循环中。完成后,服务器可以持续接受并管理大量并发连接,并正确处理边沿触发下必须读到 EAGAIN 的关键约束。

学习目标

  • 使用非阻塞监听套接字和 accept4 批量接收已排队连接。
  • 用 epoll_wait 批量分发事件,并把文件描述符映射到连接对象。
  • 正确实现 EPOLLET 下的读取与关闭路径,避免连接“有数据却不再触发”。

主循环需要维护的关系

高并发主循环并不是把 accept、recv 和 close 依次写在一个大循环里,而是让内核先报告“哪些 fd 已就绪”,用户态再只处理这些 fd。核心对象只有监听 fd、epoll 实例、就绪事件批次和连接对象表,但它们之间存在明确的数据流。

epoll 主循环的数据流与连接对象关系

示例采用 conns[fd] 直接索引连接对象。这样 epoll_event.data.fd 返回 fd 后,可以 O(1) 找到该连接的累计字节数和对端信息。真实生产系统也可以改成对象池、稠密数组或句柄表,但必须解决同一个问题:事件到达时要能定位到仍然有效的连接状态。

实现非阻塞 epoll 主循环

下面程序只负责接受连接、读取并统计输入字节,不直接回写数据。这样可以先把事件循环、ET 读取规则和连接生命周期验证清楚,避免输出缓冲问题掩盖主干逻辑。

c
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>

#define MAX_EVENTS 256
#define MAX_FD 65536

typedef struct {
    int fd;
    char peer[64];
    size_t bytes_in;
} Conn;

/* 用 fd 直接索引连接对象,事件返回后无需再次查哈希表。 */
static Conn *conns[MAX_FD];

static void close_conn(int epfd, int fd) {
    Conn *c = conns[fd];
    if (!c) return;
    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
    printf("close fd=%d peer=%s bytes=%zu\n", fd, c->peer, c->bytes_in);
    close(fd);
    free(c);
    conns[fd] = NULL;
}

static int add_conn(int epfd, int fd, const struct sockaddr_in *addr) {
    if (fd < 0 || fd >= MAX_FD) return -1;
    Conn *c = calloc(1, sizeof(*c));
    if (!c) return -1;
    c->fd = fd;
    inet_ntop(AF_INET, &addr->sin_addr, c->peer, sizeof(c->peer));

    struct epoll_event ev = {0};
    /* 连接采用边沿触发,因此读事件必须一直消费到 EAGAIN。 */
    ev.events = EPOLLIN | EPOLLRDHUP | EPOLLET;
    ev.data.fd = fd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        free(c);
        return -1;
    }
    conns[fd] = c;
    printf("accept fd=%d peer=%s:%u\n", fd, c->peer, ntohs(addr->sin_port));
    return 0;
}

static void drain_accept(int epfd, int lfd) {
    /* 一次监听事件批量接受所有已排队连接,直到 accept4 返回 EAGAIN。 */
    for (;;) {
        struct sockaddr_in addr;
        socklen_t len = sizeof(addr);
        int cfd = accept4(lfd, (struct sockaddr *)&addr, &len,
                          SOCK_NONBLOCK | SOCK_CLOEXEC);
        if (cfd >= 0) {
            if (add_conn(epfd, cfd, &addr) == -1) close(cfd);
            continue;
        }
        if (errno == EINTR) continue;
        if (errno == EAGAIN || errno == EWOULDBLOCK) break;
        perror("accept4");
        break;
    }
}

static void drain_read(int epfd, int fd) {
    char buf[4096];
    Conn *c = conns[fd];
    if (!c) return;

    /* ET 模式不能只读一次,否则剩余数据可能不会再次触发通知。 */
    for (;;) {
        ssize_t n = recv(fd, buf, sizeof(buf), 0);
        if (n > 0) {
            c->bytes_in += (size_t)n;
            continue;
        }
        if (n == 0) {
            close_conn(epfd, fd);
            return;
        }
        if (errno == EINTR) continue;
        if (errno == EAGAIN || errno == EWOULDBLOCK) return;
        close_conn(epfd, fd);
        return;
    }
}

int main(int argc, char **argv) {
    int port = argc == 2 ? atoi(argv[1]) : 8080;
    int lfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
    if (lfd == -1) { perror("socket"); return 1; }

    int one = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = htonl(INADDR_ANY),
        .sin_port = htons((uint16_t)port)
    };
    if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr)) == -1 ||
        listen(lfd, SOMAXCONN) == -1) {
        perror("bind/listen");
        return 1;
    }

    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd == -1) { perror("epoll_create1"); return 1; }

    struct epoll_event lev = { .events = EPOLLIN | EPOLLET, .data.fd = lfd };
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &lev) == -1) {
        perror("epoll_ctl");
        return 1;
    }

    printf("listening on 0.0.0.0:%d\n", port);
    struct epoll_event events[MAX_EVENTS];

    for (;;) {
        int n = epoll_wait(epfd, events, MAX_EVENTS, -1);
        if (n == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            break;
        }
        /* epoll_wait 一次返回一批就绪事件,逐个分派给监听或连接处理器。 */
        for (int i = 0; i < n; i++) {
            int fd = events[i].data.fd;
            uint32_t e = events[i].events;
            if (fd == lfd) {
                drain_accept(epfd, lfd);
                continue;
            }
            if ((e & EPOLLIN) && conns[fd]) drain_read(epfd, fd);
            if ((e & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) && conns[fd])
                close_conn(epfd, fd);
        }
    }

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

预期结果:源码保存为 epoll_server.c 后可在 Linux 上编译;服务空闲时阻塞在 epoll_wait,有连接时批量接受并注册,连接关闭时释放对应 Conn,不会通过忙轮询消耗一个 CPU 核心。

编译并验证事件分发

在终端 A 编译并启动服务。端口由命令行参数传入,因此实际监听端口可以按环境调整。

bash
gcc -std=c11 -O2 -Wall -Wextra -Werror epoll_server.c -o epoll_server
./epoll_server 8080

预期输出

text
listening on 0.0.0.0:<PORT>

其中 <PORT> 是实际传入的端口,本例为 8080。保持服务运行,再在终端 B 建立连接并发送 6 字节后主动关闭。

bash
python3 - <<'PY'
import socket

s = socket.create_connection(("127.0.0.1", 8080))
s.sendall(b"hello\n")
s.close()
PY

预期结果

text
accept fd=<ID> peer=127.0.0.1:<PORT>
close fd=<ID> peer=127.0.0.1 bytes=6

<ID> 和客户端 <PORT> 由内核动态分配,实际值会不同。服务端能统计到 6 字节,说明监听事件、连接事件、ET 读取和关闭清理已经串成完整链路。

不要破坏 ET 的两个不变量

第一,监听 fd 收到一次事件后必须反复 accept4,直到返回 EAGAIN。如果只接受一个连接,监听队列里剩余连接可能已经从“无数据”变成“有数据”过一次,却不会再产生新的边沿通知。

第二,连接 fd 的 recv 也必须持续到 EAGAIN。EPOLLET 通知的是就绪状态发生变化,而不是“缓冲区里还有多少字节”;读一小段就返回主循环,会把仍在内核接收缓冲区里的数据留成沉默数据。

这条主干刻意没有实现 send。当服务开始返回大响应时,非阻塞 send 同样可能出现部分写和 EAGAIN,必须引入输出缓冲、EPOLLOUT 订阅和背压后才能保证数据不丢。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现 epoll 事件循环主干

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通