Epoll 封装实战指南：Reactor 模式下 IO 多路转接服务器设计逻辑

1. Reactor 模式核心思想

Reactor 模式通过事件驱动实现高并发处理，核心组件包括：

• 事件分发器：监听文件描述符事件（如 epoll）
• 事件处理器：封装事件处理逻辑（回调函数）
• 事件循环：持续监听并分发事件

数学表达事件触发概率：
$$P(\text{事件触发}) = \frac{\lambda_{\text{请求}}}{\mu_{\text{处理能力}}} \quad \text{当} \ \lambda < \mu$$

2. Epoll 封装关键步骤

2.1 创建事件循环框架

struct EventLoop {
    int epoll_fd;          // epoll 实例
    struct epoll_event* events; // 就绪事件数组
    event_handler* handlers;   // 事件处理器映射
};

• 使用 epoll_create1() 初始化
• 预分配事件数组空间（建议大小：$2^n$）

2.2 事件注册机制

void register_event(EventLoop* loop, int fd, int events, 
                   void (*callback)(int, void*), void* arg) {
    struct epoll_event ev;
    ev.events = events;  // EPOLLIN | EPOLLET 等
    ev.data.ptr = create_handler(callback, arg); // 绑定回调
    
    epoll_ctl(loop->epoll_fd, EPOLL_CTL_ADD, fd, &ev);
}

• 支持事件类型：$ \text{EPOLLIN} \cup \text{EPOLLOUT} \cup \text{EPOLLERR} $
• 采用 ET 边缘触发模式提升性能

2.3 事件分发逻辑

void event_dispatch(EventLoop* loop) {
    while (1) {
        int n = epoll_wait(loop->epoll_fd, loop->events, MAX_EVENTS, -1);
        for (int i = 0; i < n; i++) {
            event_handler* h = loop->events[i].data.ptr;
            h->callback(loop->events[i].events, h->arg); // 执行回调
        }
    }
}

3. IO 多路转接服务器架构

graph TD
    A[主线程] --> B[EventLoop]
    B --> C[Accept 处理器]
    B --> D[Read 处理器]
    B --> E[Write 处理器]
    C -->|新连接| F[注册到 epoll]
    D -->|数据到达| G[业务处理]
    E -->|响应就绪| H[发送数据]

4. 性能优化要点

1. 连接管理：

   • 使用红黑树存储连接：$O(\log n)$ 查找复杂度
   • 心跳机制检测死连接

2. 缓冲区设计：

   • 双缓冲区分层：$ \text{应用层缓冲} \oplus \text{内核缓冲} $
   • 动态扩容策略：$ \text{新大小} = \lceil \text{当前大小} \times 1.5 \rceil $

3. 线程模型：

   void worker_thread() {
       while (1) {
           event_handler* task = get_from_lockfree_queue(); 
           task->callback(task->events, task->arg);  // 异步处理
       }
   }
   

   • 主线程负责 IO 事件分发
   • 工作线程池处理计算密集型任务

5. 错误处理机制

• 统一错误码映射：

  enum {
      ERR_CONN_CLOSED = 0x1001,
      ERR_BUFFER_FULL = 0x1002,
      ERR_TIMEOUT     = 0x1003
  };
  

• 错误传播链：$ \text{IO层} \rightarrow \text{业务层} \rightarrow \text{日志系统} $

6. 完整示例流程

1. 启动监听: socket() -> bind() -> listen()
2. 注册监听套接字到 epoll
3. 事件循环等待连接
4. 新连接到达: accept() -> 创建连接对象
5. 注册连接读事件到 epoll
6. 数据到达: 触发读回调 -> 解析请求 -> 加入任务队列
7. 工作线程处理任务 -> 生成响应
8. 注册写事件 -> 触发写回调发送数据

7. 关键性能指标

• 吞吐量：$ \text{QPS} = \frac{\text{成功请求数}}{\text{时间窗口}} $
• 时延分布：$ P_{\text{99}} \leq 10\text{ms} $
• 内存占用：$ \text{内存} \propto \text{连接数} \times \text{平均缓冲大小} $

最佳实践：通过 perf 工具分析热点函数，重点关注 $ \text{epoll_wait()} $ 调用频率与事件处理时延的平衡点。