操作系统 / 系统课时
实现 epoll 事件循环主干
实现 epoll 事件循环主干
这一节把监听套接字、非阻塞 accept、epoll 事件分发和连接对象收束到一个可运行主循环中。完成后,服务器可以持续接受并管理大量并发连接,并正确处理边沿触发下必须读到 EAGAIN 的关键约束。
学习目标
- 使用非阻塞监听套接字和
accept4批量接收已排队连接。 - 用
epoll_wait批量分发事件,并把文件描述符映射到连接对象。 - 正确实现
EPOLLET下的读取与关闭路径,避免连接“有数据却不再触发”。
主循环需要维护的关系
高并发主循环并不是把 accept、recv 和 close 依次写在一个大循环里,而是让内核先报告“哪些 fd 已就绪”,用户态再只处理这些 fd。核心对象只有监听 fd、epoll 实例、就绪事件批次和连接对象表,但它们之间存在明确的数据流。

示例采用 conns[fd] 直接索引连接对象。这样 epoll_event.data.fd 返回 fd 后,可以 O(1) 找到该连接的累计字节数和对端信息。真实生产系统也可以改成对象池、稠密数组或句柄表,但必须解决同一个问题:事件到达时要能定位到仍然有效的连接状态。
实现非阻塞 epoll 主循环
下面程序只负责接受连接、读取并统计输入字节,不直接回写数据。这样可以先把事件循环、ET 读取规则和连接生命周期验证清楚,避免输出缓冲问题掩盖主干逻辑。
#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 编译并启动服务。端口由命令行参数传入,因此实际监听端口可以按环境调整。
gcc -std=c11 -O2 -Wall -Wextra -Werror epoll_server.c -o epoll_server
./epoll_server 8080预期输出
listening on 0.0.0.0:<PORT>其中 <PORT> 是实际传入的端口,本例为 8080。保持服务运行,再在终端 B 建立连接并发送 6 字节后主动关闭。
python3 - <<'PY'
import socket
s = socket.create_connection(("127.0.0.1", 8080))
s.sendall(b"hello\n")
s.close()
PY预期结果
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 订阅和背压后才能保证数据不丢。