【Linux 实战 - 25】Reactor 事件驱动模型原理与实现

在高并发网络编程中，如何高效处理成千上万的连接是核心挑战。Reactor（反应器）模式作为一种经典的事件驱动设计模式，通过 I/O 多路复用技术实现了单线程（或多线程）高效处理多连接的目标，被广泛应用于 Nginx、Redis、Netty 等高性能网络框架中。

一、什么是 Reactor 模式？

Reactor 模式是一种基于事件驱动的并发处理模式，其核心思想是：

将 I/O 事件的监听、分发与业务处理解耦，通过I/O 多路复用（如 epoll、select）监听多个文件描述符（fd）的事件，当事件就绪时，将其分发给对应的事件处理器（Handler）执行。

传统多线程模型 vs Reactor 模型

• 传统多线程模型：每个连接创建一个线程，资源消耗大，并发上限低。
• Reactor 模型：单线程（或线程池）通过 I/O 多路复用监听多连接，事件就绪时才处理，资源利用率高。

二、Reactor 的核心组件

Reactor 模式由 5 个关键部分组成：

三、Reactor 的工作原理（单线程版）

单线程 Reactor 是最基础的实现，其工作流程如下：

1. 初始化：创建 Reactor、注册 Acceptor（监听 socket 的读事件）。
2. 事件循环：
   • 调用epoll_wait()阻塞等待事件就绪。
   • 若就绪事件是新连接：Acceptor 调用accept()建立连接，将新 fd 注册到 Reactor。
   • 若就绪事件是数据可读 / 可写：分发给对应的 Concrete Handler 处理。
3. 业务处理：Handler 执行handle_read()读取数据、处理业务，必要时注册写事件。

四、基于 epoll 的 Reactor 实现（C 语言示例）

以下是一个简化的单线程 Reactor 实现，使用 epoll 作为 I/O 多路复用器，支持 TCP 连接的建立与数据回显。

1. 核心数据结构

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <sys/epoll.h> #define MAX_EVENTS 1024 #define BUFFER_SIZE 1024 // 事件处理器接口 typedef struct EventHandler { int fd; void (*handle_read)(struct EventHandler *self); void (*handle_write)(struct EventHandler *self); char buffer[BUFFER_SIZE]; int buffer_len; } EventHandler; // Reactor结构体 typedef struct Reactor { int epoll_fd; struct epoll_event events[MAX_EVENTS]; EventHandler *handlers[MAX_EVENTS]; // 存储fd对应的处理器 } Reactor;

2. Reactor 初始化与事件注册

// 创建Reactor Reactor *reactor_create() { Reactor *reactor = (Reactor *)malloc(sizeof(Reactor)); reactor->epoll_fd = epoll_create1(0); memset(reactor->handlers, 0, sizeof(reactor->handlers)); return reactor; } // 注册事件到Reactor void reactor_register(Reactor *reactor, int fd, EventHandler *handler, uint32_t events) { struct epoll_event ev; ev.events = events; ev.data.fd = fd; epoll_ctl(reactor->epoll_fd, EPOLL_CTL_ADD, fd, &ev); reactor->handlers[fd] = handler; } // 事件循环 void reactor_run(Reactor *reactor) { while (1) { int n = epoll_wait(reactor->epoll_fd, reactor->events, MAX_EVENTS, -1); for (int i = 0; i < n; i++) { int fd = reactor->events[i].data.fd; EventHandler *handler = reactor->handlers[fd]; if (reactor->events[i].events & EPOLLIN) { handler->handle_read(handler); // 处理读事件 } if (reactor->events[i].events & EPOLLOUT) { handler->handle_write(handler); // 处理写事件 } } } }

3. 具体事件处理器（回显服务）

// 处理读事件（回显数据） void echo_handle_read(EventHandler *self) { int n = read(self->fd, self->buffer, BUFFER_SIZE); if (n <= 0) { close(self->fd); free(self); return; } self->buffer_len = n; // 注册写事件，准备回显数据 struct epoll_event ev; ev.events = EPOLLOUT; ev.data.fd = self->fd; epoll_ctl(epoll_fd, EPOLL_CTL_MOD, self->fd, &ev); } // 处理写事件（发送回显数据） void echo_handle_write(EventHandler *self) { write(self->fd, self->buffer, self->buffer_len); // 重新注册读事件 struct epoll_event ev; ev.events = EPOLLIN; ev.data.fd = self->fd; epoll_ctl(epoll_fd, EPOLL_CTL_MOD, self->fd, &ev); } // 创建回显处理器 EventHandler *echo_handler_create(int fd) { EventHandler *handler = (EventHandler *)malloc(sizeof(EventHandler)); handler->fd = fd; handler->handle_read = echo_handle_read; handler->handle_write = echo_handle_write; return handler; }

4. Acceptor（处理新连接）

void acceptor_handle_read(EventHandler *self) { struct sockaddr_in client_addr; socklen_t client_len = sizeof(client_addr); int client_fd = accept(self->fd, (struct sockaddr *)&client_addr, &client_len); // 创建回显处理器并注册到Reactor EventHandler *echo_handler = echo_handler_create(client_fd); reactor_register(reactor, client_fd, echo_handler, EPOLLIN); } // 创建Acceptor EventHandler *acceptor_create(int listen_fd) { EventHandler *handler = (EventHandler *)malloc(sizeof(EventHandler)); handler->fd = listen_fd; handler->handle_read = acceptor_handle_read; return handler; }

5. 主函数

int main() { // 创建监听socket int listen_fd = socket(AF_INET, SOCK_STREAM, 0); struct sockaddr_in server_addr; memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = htonl(INADDR_ANY); server_addr.sin_port = htons(8080); bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)); listen(listen_fd, 10); // 创建Reactor并注册Acceptor Reactor *reactor = reactor_create(); EventHandler *acceptor = acceptor_create(listen_fd); reactor_register(reactor, listen_fd, acceptor, EPOLLIN); // 运行事件循环 reactor_run(reactor); return 0; }

五、Reactor 模式的优缺点

优点

1. 高并发：单线程处理多连接，避免线程切换开销。
2. 解耦：事件监听、分发与业务处理分离，代码结构清晰。
3. 扩展性：可通过多线程 Reactor（主从 Reactor）进一步提升性能。

缺点

1. 单线程瓶颈：若 Handler 处理耗时过长（如 CPU 密集型任务），会阻塞整个事件循环。
2. 依赖 I/O 多路复用：需结合 epoll/kqueue 等系统调用，跨平台性略差。

六、总结

Reactor 模式是高性能网络编程的基石，通过事件驱动 + I/O 多路复用实现了高效的并发处理。在实际应用中，可根据需求选择：

• 单线程 Reactor：适用于连接数少、业务逻辑简单的场景（如 Redis）。
• 多线程 Reactor：主 Reactor 处理连接，从 Reactor 处理读写（如 Netty）。

掌握 Reactor 模式，是深入理解 Linux 网络编程与高性能框架的关键一步。

下篇预告：【Linux 实战 - 26】轻量级 HTTP 服务器原理与 C 语言 Socket 实现

原创不易，如果本文对你有帮助，欢迎点赞、收藏、关注三连！有任何问题都可以在评论区留言，我会及时回复。