操作系统 / 系统课时
用 Reactor 组织事件处理流程
用 Reactor 组织事件处理流程
把 epoll_wait、连接状态和业务处理都塞进一个巨大循环,代码很快会变得难以扩展。本节把事件驱动程序拆成 Reactor 结构:EventLoop 只负责等待和分发,Connection 保存连接上下文,Handler 处理具体事件,从而让“监听谁、状态放哪、事件交给谁”都有明确边界。
学习目标
- 说明
EventLoop、Connection与Handler的职责和依赖关系 - 把
epoll返回的就绪事件分发到对应连接对象 - 识别 Reactor 中不能放进事件循环的阻塞操作
Reactor 的职责边界
Reactor 的关键不是类名,而是把事件检测与事件处理分开。EventLoop 持有 epoll 实例,负责注册文件描述符、调用 epoll_wait、找到事件对应对象并分发;它不应该理解业务协议。
Connection 表示一条连接的长期上下文,通常保存 fd、输入缓冲区、输出缓冲区、协议解析状态和所属 EventLoop。Handler 则是连接收到可读、可写、错误或关闭事件后执行的处理逻辑。

在 C 里常见做法是把 Connection * 放进 epoll_event.data.ptr。这样 epoll_wait 返回后无需再用 fd 查询全局表,就能直接拿到连接上下文并调用绑定的回调。
用最小程序完成一次分发
下面示例用 socketpair 代替真实客户端连接,重点验证 Reactor 的组织方式,而不是网络握手。客户端一端写入 ping,EventLoop 收到 EPOLLIN 后取得 Connection *,再把事件交给 on_readable;Handler 读取数据并回复 pong:ping。
将下面内容保存为 reactor_demo.c:
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
typedef struct EventLoop EventLoop;
typedef struct Connection Connection;
typedef void (*Handler)(Connection *conn, uint32_t events);
struct EventLoop {
int epfd;
};
struct Connection {
int fd;
EventLoop *loop;
Handler handler;
};
static void set_nonblocking(int fd) {
int flags = fcntl(fd, F_GETFL, 0);
if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
perror("fcntl");
exit(1);
}
}
static void event_loop_add(EventLoop *loop, Connection *conn) {
struct epoll_event ev = {
.events = EPOLLIN | EPOLLET,
.data.ptr = conn
};
if (epoll_ctl(loop->epfd, EPOLL_CTL_ADD, conn->fd, &ev) == -1) {
perror("epoll_ctl");
exit(1);
}
}
static void on_readable(Connection *conn, uint32_t events) {
if ((events & EPOLLIN) == 0) {
return;
}
for (;;) {
char buf[64];
ssize_t n = read(conn->fd, buf, sizeof(buf) - 1);
if (n > 0) {
buf[n] = '\0';
printf("handler received: %s\n", buf);
char reply[80];
int len = snprintf(reply, sizeof(reply), "pong:%s", buf);
if (write(conn->fd, reply, (size_t)len) == -1) {
perror("write");
exit(1);
}
continue;
}
if (n == -1 && errno == EAGAIN) {
return;
}
if (n == 0) {
return;
}
perror("read");
exit(1);
}
}
static void event_loop_once(EventLoop *loop) {
struct epoll_event events[8];
int n = epoll_wait(loop->epfd, events, 8, 1000);
if (n == -1) {
perror("epoll_wait");
exit(1);
}
for (int i = 0; i < n; ++i) {
Connection *conn = events[i].data.ptr;
conn->handler(conn, events[i].events);
}
}
int main(void) {
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
perror("socketpair");
return 1;
}
set_nonblocking(sv[1]);
EventLoop loop = {.epfd = epoll_create1(0)};
if (loop.epfd == -1) {
perror("epoll_create1");
return 1;
}
Connection server_conn = {
.fd = sv[1],
.loop = &loop,
.handler = on_readable
};
event_loop_add(&loop, &server_conn);
write(sv[0], "ping", 4);
event_loop_once(&loop);
char reply[64] = {0};
ssize_t n = read(sv[0], reply, sizeof(reply) - 1);
printf("client received: %.*s\n", (int)n, reply);
close(loop.epfd);
close(sv[0]);
close(sv[1]);
return 0;
}预期结果:源码可在 Linux 上编译;一次 epoll_wait 得到就绪连接后,EventLoop 只负责分发,实际读取与响应由 Handler 完成。
gcc -Wall -Wextra -O2 reactor_demo.c -o reactor_demo && ./reactor_demo预期输出:
handler received: ping
client received: pong:ping这里的 socketpair 只是让示例不依赖端口和外部客户端。换成真实 TCP 服务器时,监听 fd 也可以注册到同一个 EventLoop:它的 Handler 负责循环 accept 新连接,再为每个连接创建 Connection 并注册读写事件。
把状态放回 Connection
真正的网络服务器不能假设一次 read 就得到完整请求,也不能假设一次 write 就发送完响应。因此跨事件循环仍需保留的数据,应归属于 Connection,而不是 Handler 的栈变量。
典型状态包括输入缓冲区、输出缓冲区、解析进度、关闭标记和超时信息。Handler 每次只根据当前事件推进状态。例如响应只写出一部分时,把剩余字节留在输出缓冲区并关注 EPOLLOUT;发送完毕后再取消 EPOLLOUT,避免可写事件持续唤醒事件循环。
避免把 EventLoop 重新写成巨型函数
判断职责是否清晰,可以看三个问题:等待事件的代码是否知道业务协议;业务 Handler 是否自己调用 epoll_wait;连接的跨事件状态是否散落在全局变量里。如果答案分别是“是、是、是”,说明边界又混在一起了。
一个可控的 Reactor 应保持单向流程:EventLoop 发现就绪对象,Connection 提供状态,Handler 推进一次处理,再把新的关注事件和待发送数据交还给 EventLoop 管理。这样后续加入监听连接、定时器、连接关闭和线程池时,不需要推翻整个事件循环。