操作系统 / 系统课时

用 Reactor 组织事件处理流程

用 Reactor 组织事件处理流程

把 epoll_wait、连接状态和业务处理都塞进一个巨大循环,代码很快会变得难以扩展。本节把事件驱动程序拆成 Reactor 结构:EventLoop 只负责等待和分发,Connection 保存连接上下文,Handler 处理具体事件,从而让“监听谁、状态放哪、事件交给谁”都有明确边界。

学习目标

  • 说明 EventLoop、Connection 与 Handler 的职责和依赖关系
  • 把 epoll 返回的就绪事件分发到对应连接对象
  • 识别 Reactor 中不能放进事件循环的阻塞操作

Reactor 的职责边界

Reactor 的关键不是类名,而是把事件检测与事件处理分开。EventLoop 持有 epoll 实例,负责注册文件描述符、调用 epoll_wait、找到事件对应对象并分发;它不应该理解业务协议。

Connection 表示一条连接的长期上下文,通常保存 fd、输入缓冲区、输出缓冲区、协议解析状态和所属 EventLoop。Handler 则是连接收到可读、可写、错误或关闭事件后执行的处理逻辑。

Reactor 组件与事件分发关系

在 C 里常见做法是把 Connection * 放进 epoll_event.data.ptr。这样 epoll_wait 返回后无需再用 fd 查询全局表,就能直接拿到连接上下文并调用绑定的回调。

用最小程序完成一次分发

下面示例用 socketpair 代替真实客户端连接,重点验证 Reactor 的组织方式,而不是网络握手。客户端一端写入 ping,EventLoop 收到 EPOLLIN 后取得 Connection *,再把事件交给 on_readable;Handler 读取数据并回复 pong:ping。

将下面内容保存为 reactor_demo.c:

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 完成。

bash
gcc -Wall -Wextra -O2 reactor_demo.c -o reactor_demo && ./reactor_demo

预期输出:

text
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 管理。这样后续加入监听连接、定时器、连接关闭和线程池时,不需要推翻整个事件循环。

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

目录与阅读设置

阅读设置

17

记录一个想法

用 Reactor 组织事件处理流程

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

登录哪都通