💬 :如果你在阅读过程中有任何疑问或想要进一步探讨的内容,欢迎在评论区畅所欲言!我们一起学习、共同成长~!
👍 :如果你觉得这篇文章还不错,不妨顺手点个赞、加入收藏,并分享给更多的朋友噢~!
引言 :上一章《Linux 网络(11):IO 多路转接》我们已经使用过 epoll,但 epoll 只做一件事------告诉你哪些 fd 就绪 。至于"就绪之后该做什么、谁去做、做完怎么继续等待",epoll 完全不管。Reactor 模式解决的正是这后半段:把就绪事件自动派发给对应的处理函数。 相当于 epoll 是一个 API,Reactor 是一套架构。
📌 联动 :socket 创建/绑定/监听、accept 与 read 返回值三态见《Linux网络(03):Socket 编程 TCP》;EPOLLIN/EPOLLOUT/EPOLLET 语义、ET 必须非阻塞见《Linux 网络(11):IO 多路转接》4.4~4.5;非阻塞设置与 errno 三分支见《Linux网络(10):五种 IO 模型》4.2、4.4;线程池实现见《Linux系统(11):线程池实现》。
1. Reactor 模式:把"等"和"处理"拆开
1.1 为什么需要 Reactor【必考核心】
考察形式:一面基础问答("Reactor 是什么 / 解决什么问题 / 有什么优缺点");场景选型("十万连接该用什么模型")。
前两章我们已经遇到过两种失败方案,这里先用一张表把它们和 Reactor 并列比较:
| 方案 | 等的方式 | 处理方式 | 致命问题 |
|---|---|---|---|
| 单执行流阻塞服务器 | 阻塞 read/accept,只能等 1 个 fd | 自己处理 | 串行,第 2 个客户端只能排队 |
| 每连接一线程 / 一进程 | 各线程各自阻塞等 | 各线程自己处理 | 连接上万时创建/切换开销会压垮机器 |
| Reactor(多路转接 + 事件派发) | 1 个线程用 epoll 批量等多个 fd | 按 fd 到回调表的映射找到该调用的回调 | 依赖"处理不阻塞",否则会拖住整个事件循环(后文 3. 说明对策) |
Reactor 是什么: Reactor 是一种事件驱动的 IO 设计模式 ,依托 IO 多路复用(epoll),由一个 / 少数几个事件循环线程统一监听大量 fd,事件就绪后按"fd → 处理函数"的映射把事件派发给预先注册好的回调函数执行。
Reactor 解决什么问题: 解决传统模型痛点:单线程阻塞模型只能串行处理客户端;每连接一线程模型在海量连接下,线程创建、上下文切换、内存资源开销巨大。Reactor 用少量线程同时管理成千上万连接,复用等待 IO 的时间,提升并发能力。
优缺点:优点是并发高、线程开销小;核心缺点是回调不能阻塞,任何一个回调阻塞,整个事件循环都会停止。
1.2 Reactor 的角色构成与工作流程【必考核心】
Reactor 主要由五个角色构成:
| 角色 | 解释 | 在 Linux 里是什么 |
|---|---|---|
| Handle(句柄) | 标识一个事件 | 文件描述符 fd |
| Synchronous Event Demultiplexer(同步事件分离器) | 等待事件发生的系统调用 | IO 多路复用,如 epoll 等。Reactor 是以 epoll 为同步事件分离器的一套事件派发架构 |
| Event Handler(事件处理器) | 一组回调方法 | 读回调 / 写回调 / 异常回调 三个函数指针 |
| Concrete Event Handler(具体事件处理器) | 回调的具体实现 | |
| Initiation Dispatcher(初始分发器) | 就是 Reactor 本体,通过同步事件分离器来等待事件发生,对应事件就绪时调用事件处理器,最后调用具体事件处理器来处理该事件 |
Reactor 处理一次事件的完整工作流程:
- 注册:应用向初始分发器注册事件处理器,登记 fd、关心的 IO 事件、就绪后执行的回调函数。
- 等待:启动初始分发器的事件循环,由同步事件分离器(epoll/select/poll)阻塞等待这些 fd 上的 IO 事件就绪。
- 查找:同步事件分离器检测到某个 fd 就绪,通知初始分发器,分发器以就绪的 fd 为索引,匹配对应的事件处理器。
- 派发:初始分发器调用事件处理器内注册好的回调方法,处理完继续等待。
查找派发如图:

1.3 Reactor 与 Proactor【必考核心】
考察形式:概念辨析选择题 + 一面开场追问出现率很高
| 维度 | Reactor(反应堆) | Proactor(前摄器) |
|---|---|---|
| 谁做真正的 IO(数据拷贝) | 应用本身(回调里 read/recv、write/send) | 内核(应用只发请求、收完成通知) |
| 通知什么 | "可以读了/可以写了"(就绪) | "已经读完了"(完成) |
| 同步/异步 | 同步 IO(进程参与了 IO 全过程) | 异步 IO |
| Linux 中代表 | epoll / select / poll + 事件循环 | io_uring、Windows IOCP |
💡epoll 是同步事件分离器,所以基于 epoll 的服务器天然属于 Reactor,而不是 Proactor。原因很朴素:epoll 只通知"fd 可读",这次拷贝仍然是应用本身在回调里做的。
- ❌"epoll 是异步"是流传很广的错误说法。
1.4 Reactor 三种演进形态【进阶拔高】
考察形式:二面追问("你的 Reactor 有几个线程?业务耗时怎么处理?");项目亮点(能讲清为什么这样分层)。
| 形态 | 结构 | 瓶颈 / 适用 |
|---|---|---|
| ① 单 Reactor 单线程 | 1 线程:等事件 + 读数据 + 算业务 + 写响应 | 业务一慢全卡;入门必写,也是面试手撕默认答案 |
| ② 单 Reactor 多线程 | 1 个 IO 线程负责等/读写,业务丢给线程池 | IO 与业务解耦(详见 3.) |
| ③ 主从 Reactor | 主 Reactor 只管 accept,把新连接分给多个子 Reactor(各带 1 个 loop + 1 个线程) | muduo 的典型实现;只有多核才能充分利用多核 |
2. Reactor 模式下的 epoll ET 服务器
💡【学习建议】:
- 第一遍只抓主线:看 2.1 事件表 → 2.2 两个结构 → 2.3 派发事件循环三步 → 2.5 四回调职责。先不看代码细节,目标是能口述 "Reactor 怎么跑起来"。
看完再基于前文 1.2 所说的 "Reactor 处理一次事件的完整工作流程",Reactor 模式下的 epoll ET 服务器工作流程如下:
- 注册:把 fd、关心事件、回调打包注册进 Reactor;启动时注册监听 fd;accepter 拿到新连接后,用 AddEvent 完成新连接注册。
- 等待:Reactor 启动派发事件循环,epoll_wait 阻塞等待 fd 就绪。
- 查找:epoll 上报就绪 fd,Reactor 通过 fd 索引找到对应的 EventItem。
- 派发:执行 EventItem 绑定的回调:
- 监听 fd 的读事件就绪 → accepter,拿到新连接,再次走注册;
- 普通 fd 的读事件就绪 → recver,收数据、业务处理,按需开启写事件;
- 普通 fd 的写事件就绪 → sender,发送缓冲区数据,按需关闭写事件;
- 异常事件发生 → errorer,摘除 fd、关闭套接字; 回调处理完毕,回到等待,循环往复。
- 第二遍对着代码对位置:每段代码理解 "它在主线哪一步",对上就过,不追语法细节。
- 第三遍默骨架:只默 EventItem 成员、派发事件循环三步、四回调职责。工程完整代码本地跑通一次即可,不背全量。
2.1 四类事件 → 四个回调【必考核心】
epoll ET 服务器中需要处理如下几种事件:
| 就绪事件 | 出现在谁身上 |
|---|---|
| 读事件 EPOLLIN | 监听 fd |
| 读事件 EPOLLIN | 连接 fd |
| 写事件 EPOLLOUT | 连接 fd |
| 异常 EPOLLERR / EPOLLHUP | 任意 fd |
监听套接字与连接套接字复用同一个读回调字段:监听套接字的读事件就绪就意味着连接事件就绪,所以它的读回调设置为 accepter;监听套接字一般只关心读事件,写回调、异常回调设置为 nullptr。
Reactor 模式的五个角色,在这个服务器中的对应关系:
| 教科书角色 | 本服务器中的对应物 |
|---|---|
| 句柄 Handle | 文件描述符 fd |
| 同步事件分离器 | IO 多路复用 epoll |
| 事件处理器 | 读回调、写回调、异常回调 |
| 具体事件处理器 | 三个回调的具体实现 |
| 初始分发器 | Reactor 类中的 Dispatcher 函数 |
2.2 两个核心数据结构【必考核心】
回调定好了,现在解决 "回调存在哪里、事件来了怎么找到对应回调"。两个核心数据结构,EventItem 描述单个 fd 的全部信息(2.2.1),Reactor 负责在所有连接里按 fd 快速检索(2.2.2)。
2.2.1 EventItem 类**:单个 fd 的全部信息**
在注册事件处理器时,需要把读回调、写回调、异常回调与某个文件描述符关联起来。这样当某个 fd 上的事件就绪时,才能找到它对应的回调函数并执行。于是 EventItem 将一个 fd 的事件关心集合 + 三个回调 + 两个缓冲区 + 回指指针" 组织在一起。
📝 掌握程度:记住 "fd 的事件位 + 三个回调 + 两个缓冲区 + 回指指针" 打包在一个对象里;能说出每个成员的用途即可。
| 成员 | 作用 |
|---|---|
_sock |
文件描述符(句柄):事件派发后要拿它做 IO |
_recv_handler / _send_handler / _error_handler |
读 / 写 / 异常回调:事件派发时最终要调用它们 |
_inbuffer |
输入缓冲区:recv 不能保证读到一个完整报文,先暂存,攒出完整报文后再分离处理(解决粘包问题) |
_outbuffer |
输出缓冲区:TCP 发送缓冲区可能没有足够空间,待发数据先暂存,写事件就绪后再依次发送 |
_R |
回指指针:回调需要反向操作 Reactor(注册新连接、开写事件)时,没有这个指针就访问不到 Reactor |
2.2.2 Reactor :初始分发器本体
Reactor 类中有两个成员:
- 一个 _epfd 成员,记录 epoll 模型对应的 fd。
- 一个 unordered_map 成员,用于建立 fd 与对应 EventItem 间的映射。
cpp
// ---------- Reactor:初始分发器本体 ----------
class Reactor
{
private:
int _epfd;
std::unordered_map<int, EventItem> _event_items; // fd → EventItem 映射
public:
Reactor() : _epfd(-1) {}
void InitReactor()
{
_epfd = epoll_create(SIZE);
if (_epfd < 0) { std::cerr << "epoll_create error" << std::endl; exit(5); }
}
~Reactor() { if (_epfd >= 0) close(_epfd); }
// 下文 2.3、2.4 补齐 Dispatcher / AddEvent / DelEvent / EnableReadWrite
};
2.3 Dispatcher 函数:等待、查找、派发**【必考核心】**
Dispatcher 就是前面所说的初始分发器。派发事件循环三步:Dispatcher 调用 epoll_wait 等待事件就绪 → 某个 fd 上的事件就绪后,先按 fd 从 map 取对应的 EventItem → 再调用其中对应的回调处理该事件。
cpp
// 事件分派器:epoll_wait 拿就绪 fd,按事件位图回调
void Dispatcher(int timeout)
{
struct epoll_event revs[MAX_NUM];
int num = epoll_wait(_epfd, revs, MAX_NUM, timeout);
for (int i = 0; i < num; i++) {
int sock = revs[i].data.fd;
if ((revs[i].events & EPOLLERR) || (revs[i].events & EPOLLHUP)) { // 异常优先
if (_event_items[sock]._error_handler)
_event_items[sock]._error_handler(&_event_items[sock]);
}
if (revs[i].events & EPOLLIN) {
if (_event_items[sock]._recv_handler)
_event_items[sock]._recv_handler(&_event_items[sock]);
}
if (revs[i].events & EPOLLOUT) {
if (_event_items[sock]._send_handler)
_event_items[sock]._send_handler(&_event_items[sock]);
}
}
}
- 这里没有用 switch/if 判断
epoll_wait的返回值,而是借助 for 循环处理:返回 -1 表示调用失败,返回 0 表示超时,两种情况都不会进入循环;返回大于 0 才进入循环调用对应回调。 - 事件处理时先处理异常事件,所以代码把异常事件的判断放在最前面。
2.4 注册、删除、修改事件三类操作【必考核心】
除了派发事件,Reactor 还需要三个配套操作:把事件注册进去、从里面删掉、修改某个 fd 关心的事件。
2.4.1 AddEvent:注册事件
【注册】把 fd 和要监视的事件集合注册到 epoll 模型,再建立 fd 与 EventItem 的映射关系。
cpp
// 注册事件:epoll_ctl ADD + 建立 fd→EventItem 映射
void AddEvent(int sock, uint32_t event, const EventItem& item)
{
struct epoll_event ev;
ev.data.fd = sock;
ev.events = event;
if (epoll_ctl(_epfd, EPOLL_CTL_ADD, sock, &ev) < 0) {
std::cerr << "epoll_ctl add error, fd: " << sock << std::endl;
} else {
_event_items.insert({ sock, item });
std::cout << "添加: " << sock << " 到epoll模型中,成功" << std::endl;
}
}
2.4.2 DelEvent:删除事件
【派发收尾】异常时,该 fd 从 epoll 模型中删除,并取消它与 EventItem 的映射关系。
cpp
// 删除事件:epoll_ctl DEL + 取消映射
void DelEvent(int sock)
{
if (epoll_ctl(_epfd, EPOLL_CTL_DEL, sock, nullptr) < 0)
std::cerr << "epoll_ctl del error, fd: " << sock << std::endl;
_event_items.erase(sock);
std::cout << "从epoll模型中删除: " << sock << ",成功" << std::endl;
}
2.4.3 EnableReadWrite:修改读写事件
【派发中】读事件经常设置,写事件则按需打开,数据全部写完后立即关闭写事件。
cpp
// 修改读写事件
void EnableReadWrite(int sock, bool read, bool write)
{
struct epoll_event ev;
ev.data.fd = sock;
ev.events = (read ? (uint32_t)EPOLLIN : 0u) | (write ? (uint32_t)EPOLLOUT : 0u) | EPOLLET;
if (epoll_ctl(_epfd, EPOLL_CTL_MOD, sock, &ev) < 0)
std::cerr << "epoll_ctl mod error, fd: " << sock << std::endl;
}
- 写事件是按需打开的 :
accept获取上来的套接字注册时只添加EPOLLIN | EPOLLET,即只让 epoll 关心读事件;当前没有要发送的数据时,不必让 epoll 关心写事件。读事件经常设置,写事件则按需打开,数据全部写完后立即关闭写事件。
2.5 四个回调【必考核心】
注册和派发都清楚后,重点看四个回调。
| 回调 | 职责 |
|---|---|
accepter |
连接事件到来时,获取底层建立好的连接 |
recver |
读事件就绪时,读取客户端发来的数据并处理 |
sender |
写事件就绪时,向客户端发送响应数据 |
errorer |
异常事件就绪时,关闭对应的文件描述符 |
ET 模式只有在状态变化(底层连接从无到有 / 从有到多)时才会通知上层一次,如果没有一次性把就绪的连接 / 数据全部取完,此后又没有新事件到来,剩下部分就不会再通知。因此连接、读、写事件都要循环处理,直到暂时没有更多数据或连接。(📌 联动:《Linux系统(11):线程池实现》4.4 LT 水平触发 和 ET 边缘触发)
2.5.1 accepter 回调:连接事件
【派发】监听 fd 的读事件就绪 → accepter,拿到新连接,再次走注册
cpp
// ---------- 回调 1:连接事件 ----------
int accepter(EventItem* item)
{
while (true) {
struct sockaddr_in peer;
memset(&peer, 0, sizeof(peer));
socklen_t len = sizeof(peer);
int sock = accept(item->_sock, (struct sockaddr*)&peer, &len);
if (sock < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) return 0; // 本轮连接取净
else if (errno == EINTR) continue; // 被信号中断
else { std::cerr << "accept error" << std::endl; return -1; }
}
SetNonBlock(sock);
EventItem sock_item;
sock_item._sock = sock;
sock_item._R = item->_R;
sock_item.ManageCallbacks(recver, sender, errorer);
item->_R->AddEvent(sock, EPOLLIN | EPOLLET, sock_item);
}
return 0;
}
为什么监听 fd 和新 fd 都要非阻塞 :ET 下需要循环调用 accept,底层连接全部取完后再调用 accept 会因为没有连接而被阻塞住;设为非阻塞后,没有连接时 accept 直接返回。新套接字也设为非阻塞,是为了避免将来循环调用 recv、send 时被阻塞。
accept 返回 -1 时的错误码判断 :EAGAIN/EWOULDBLOCK 表示底层已没有可获取的连接,本轮获取完毕;EINTR 表示被信号中断,继续调用 accept;其余情况才是真正失败。
设置文件描述符为非阻塞 :先用 fcntl 获取文件状态标记,在其基础上加上 O_NONBLOCK,再写回。
📝 掌握程度:记住三步 F_GETFL 读标志 → fl | O_NONBLOCK → F_SETFL 写回;关键坑是不能直接 fl = O_NONBLOCK 覆盖掉其他已有标志。
cpp
// ---------- 工具:把 fd 设为非阻塞 ----------
bool SetNonBlock(int sock)
{
int fl = fcntl(sock, F_GETFL);
if (fl < 0) { std::cerr << "fcntl error" << std::endl; return false; }
fcntl(sock, F_SETFL, fl | O_NONBLOCK);
return true;
}
2.5.2 recver:读事件 + 业务处理
【派发】普通 fd 的读事件就绪 → recver,收数据、业务处理,按需开启写事件
cpp
// ---------- 回调 2:读事件 + 业务 ----------
int recver(EventItem* item)
{
if (item->_sock < 0) return -1; // 已关闭
if (recver_helper(item->_sock, &(item->_inbuffer)) < 0) {
item->_error_handler(item);
return -1;
}
std::vector<std::string> datagrams;
StringUtil::Split(item->_inbuffer, &datagrams, "X");
for (auto s : datagrams) {
struct data d;
StringUtil::Deserialize(s, &d._x, &d._y, &d._op);
int result = 0;
switch (d._op) {
case '+': result = d._x + d._y; break;
case '-': result = d._x - d._y; break;
case '*': result = d._x * d._y; break;
case '/':
if (d._y == 0) { std::cerr << "Error: div zero!" << std::endl; continue; }
result = d._x / d._y; break;
case '%':
if (d._y == 0) { std::cerr << "Error: mod zero!" << std::endl; continue; }
result = d._x % d._y; break;
default:
std::cerr << "operation error!" << std::endl; continue;
}
std::string response;
response += std::to_string(d._x);
response += d._op;
response += std::to_string(d._y);
response += "=";
response += std::to_string(result);
response += "X";
item->_outbuffer += response;
if (!item->_outbuffer.empty())
item->_R->EnableReadWrite(item->_sock, true, true);
}
return 0;
}
2.5.3 sender:写事件
【派发】普通 fd 的写事件就绪 → sender,发送缓冲区数据,按需关闭写事件
cpp
// ---------- 回调 3:写事件 ----------
int sender(EventItem* item)
{
if (item->_sock < 0) return -1;
int ret = sender_helper(item->_sock, item->_outbuffer);
if (ret == 0) {
item->_R->EnableReadWrite(item->_sock, true, false); // 发完,关写事件
} else if (ret == 1) {
item->_R->EnableReadWrite(item->_sock, true, true); // 没发完,继续关心
} else {
item->_error_handler(item);
}
return 0;
}
2.5.4 errorer:异常事件 / 对端关闭
【派发】异常事件发生 → errorer,摘除 fd、关闭套接字; 回调处理完毕,回到等待,循环往复。
cpp
// ---------- 回调 4:异常 / 对端关闭 ----------
int errorer(EventItem* item)
{
int sock = item->_sock;
item->_R->DelEvent(sock); // ① 先从 epoll 摘除并取消映射
close(sock); // ② 再关闭 fd
item->_sock = -1; // ③ 置 -1,防止后续读写回调再进入
return 0;
}
2.6 多文件工程完整代码
各文件内容总览
| 文件 | 放什么 | 对应小节 |
|---|---|---|
app_interface.hpp |
系统头文件、宏、前置声明、struct data、EventItem、回调与 helper 前置声明 |
2.2.1 |
reactor.hpp |
Reactor 类:InitReactor / Dispatcher / AddEvent / DelEvent / EnableReadWrite |
2.2.2、2.3、2.4 |
util.hpp |
SetNonBlock、StringUtil、recver_helper、sender_helper |
2.5.1、2.5.2、2.5.3 |
socket.hpp |
Socket 静态封装类 |
2.7 main 调用 |
| reactor_server.cpp | 四个回调实现 + main |
2.5.1~2.5.4、main |
2.6.1 app_interface.hpp
cpp
#ifndef APP_INTERFACE_HPP
#define APP_INTERFACE_HPP
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <cstdlib>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define SIZE 256
#define MAX_NUM 64
#define BACK_LOG 5
struct data { int _x; int _y; char _op; };
class Reactor;
class EventItem;
typedef int (*callback_t)(EventItem*);
// ---------- EventItem:一个 fd 的完整记录 ----------
class EventItem
{
public:
int _sock; // 文件描述符
Reactor* _R; // 回指指针
callback_t _recv_handler; // 读回调
callback_t _send_handler; // 写回调
callback_t _error_handler; // 异常回调
std::string _inbuffer; // 输入缓冲区
std::string _outbuffer; // 输出缓冲区
public:
EventItem()
: _sock(-1), _R(nullptr)
, _recv_handler(nullptr), _send_handler(nullptr), _error_handler(nullptr)
{}
void ManageCallbacks(callback_t recv_handler, callback_t send_handler, callback_t error_handler)
{
_recv_handler = recv_handler;
_send_handler = send_handler;
_error_handler = error_handler;
}
};
// ---------- 四个回调前置声明 ----------
int accepter(EventItem* item);
int recver(EventItem* item);
int sender(EventItem* item);
int errorer(EventItem* item);
// ---------- 读写辅助前置声明 ----------
int recver_helper(int sock, std::string* out);
int sender_helper(int sock, std::string& in);
#endif
2.6.2 reactor.hpp
cpp
#ifndef REACTOR_HPP
#define REACTOR_HPP
#include "app_interface.hpp"
// ---------- Reactor:初始分发器本体 ----------
class Reactor
{
private:
int _epfd;
std::unordered_map<int, EventItem> _event_items; // fd → EventItem 映射
public:
Reactor() : _epfd(-1) {}
void InitReactor()
{
_epfd = epoll_create(SIZE);
if (_epfd < 0) { std::cerr << "epoll_create error" << std::endl; exit(5); }
}
~Reactor() { if (_epfd >= 0) close(_epfd); }
// 注册事件:epoll_ctl ADD + 建立 fd→EventItem 映射
void AddEvent(int sock, uint32_t event, const EventItem& item)
{
struct epoll_event ev;
ev.data.fd = sock;
ev.events = event;
if (epoll_ctl(_epfd, EPOLL_CTL_ADD, sock, &ev) < 0) {
std::cerr << "epoll_ctl add error, fd: " << sock << std::endl;
} else {
_event_items.insert({ sock, item });
std::cout << "添加: " << sock << " 到epoll模型中,成功" << std::endl;
}
}
// 删除事件:epoll_ctl DEL + 取消映射
void DelEvent(int sock)
{
if (epoll_ctl(_epfd, EPOLL_CTL_DEL, sock, nullptr) < 0)
std::cerr << "epoll_ctl del error, fd: " << sock << std::endl;
_event_items.erase(sock);
std::cout << "从epoll模型中删除: " << sock << ",成功" << std::endl;
}
// 修改读写事件
void EnableReadWrite(int sock, bool read, bool write)
{
struct epoll_event ev;
ev.data.fd = sock;
ev.events = (read ? (uint32_t)EPOLLIN : 0u) | (write ? (uint32_t)EPOLLOUT : 0u) | EPOLLET;
if (epoll_ctl(_epfd, EPOLL_CTL_MOD, sock, &ev) < 0)
std::cerr << "epoll_ctl mod error, fd: " << sock << std::endl;
}
// 事件分派器:epoll_wait 拿就绪 fd,按事件位图回调
void Dispatcher(int timeout)
{
struct epoll_event revs[MAX_NUM];
int num = epoll_wait(_epfd, revs, MAX_NUM, timeout);
for (int i = 0; i < num; i++) {
int sock = revs[i].data.fd;
if ((revs[i].events & EPOLLERR) || (revs[i].events & EPOLLHUP)) { // 异常优先
if (_event_items[sock]._error_handler)
_event_items[sock]._error_handler(&_event_items[sock]);
}
if (revs[i].events & EPOLLIN) {
if (_event_items[sock]._recv_handler)
_event_items[sock]._recv_handler(&_event_items[sock]);
}
if (revs[i].events & EPOLLOUT) {
if (_event_items[sock]._send_handler)
_event_items[sock]._send_handler(&_event_items[sock]);
}
}
}
};
#endif
2.6.3 util.hpp
cpp
#ifndef UTIL_HPP
#define UTIL_HPP
#include "app_interface.hpp"
// ---------- 工具:把 fd 设为非阻塞 ----------
bool SetNonBlock(int sock)
{
int fl = fcntl(sock, F_GETFL);
if (fl < 0) { std::cerr << "fcntl error" << std::endl; return false; }
fcntl(sock, F_SETFL, fl | O_NONBLOCK);
return true;
}
// ---------- 字符串工具:切包 + 反序列化 ----------
class StringUtil
{
public:
static void Split(std::string& in, std::vector<std::string>* out, std::string sep)
{
int start = 0;
size_t pos = in.find(sep, start);
while (pos != std::string::npos) {
out->push_back(in.substr(start, pos - start));
start = pos + sep.size();
pos = in.find(sep, start);
}
in = in.substr(start);
}
static void Deserialize(std::string& in, int* x, int* y, char* op)
{
size_t pos = 0;
for (pos = 0; pos < in.size(); pos++) {
if (in[pos] == '+' || in[pos] == '-' || in[pos] == '*' ||
in[pos] == '/' || in[pos] == '%') break;
}
if (pos < in.size()) {
*x = atoi(in.substr(0, pos).c_str());
*y = atoi(in.substr(pos + 1).c_str());
*op = in[pos];
} else {
*op = -1;
}
}
};
// ---------- 读辅助:循环 recv 到 EAGAIN ----------
int recver_helper(int sock, std::string* out)
{
while (true) {
char buffer[128];
ssize_t size = recv(sock, buffer, sizeof(buffer) - 1, 0);
if (size < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) return 0; // 数据读完
else if (errno == EINTR) continue; // 被信号中断,重试
else return -1; // 读取出错
} else if (size == 0) {
return -1; // 对端关闭
}
buffer[size] = '\0';
*out += buffer;
}
}
// ---------- 写辅助:循环 send,返回 0 全发完 / 1 没发完 / -1 出错 ----------
int sender_helper(int sock, std::string& in)
{
size_t total = 0;
while (true) {
ssize_t size = send(sock, in.c_str() + total, in.size() - total, 0);
if (size < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
in.erase(0, total); // 已发送部分移出 outbuffer
return 1;
} else if (errno == EINTR) {
continue;
} else {
return -1;
}
}
total += size;
if (total >= in.size()) { in.clear(); return 0; }
}
}
#endif
2.6.4 socket.hpp
cpp
#ifndef SOCKET_HPP
#define SOCKET_HPP
#include "app_interface.hpp"
// ---------- 套接字封装 ----------
class Socket
{
public:
static int SocketCreate()
{
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) { std::cerr << "socket error" << std::endl; exit(2); }
int opt = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
return sock;
}
static void SocketBind(int sock, int port)
{
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = INADDR_ANY;
if (bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0) {
std::cerr << "bind error" << std::endl; exit(3);
}
}
static void SocketListen(int sock, int backlog)
{
if (listen(sock, backlog) < 0) { std::cerr << "listen error" << std::endl; exit(4); }
}
};
#endif
2.6.5 reactor_server.cpp
cpp
#include "app_interface.hpp"
#include "reactor.hpp"
#include "socket.hpp"
#include "util.hpp"
// ---------- 回调 1:连接事件 ----------
int accepter(EventItem* item)
{
while (true) {
struct sockaddr_in peer;
memset(&peer, 0, sizeof(peer));
socklen_t len = sizeof(peer);
int sock = accept(item->_sock, (struct sockaddr*)&peer, &len);
if (sock < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) return 0; // 本轮连接取净
else if (errno == EINTR) continue; // 被信号中断
else { std::cerr << "accept error" << std::endl; return -1; }
}
SetNonBlock(sock);
EventItem sock_item;
sock_item._sock = sock;
sock_item._R = item->_R;
sock_item.ManageCallbacks(recver, sender, errorer);
item->_R->AddEvent(sock, EPOLLIN | EPOLLET, sock_item);
}
return 0;
}
// ---------- 回调 2:读事件 + 业务 ----------
int recver(EventItem* item)
{
if (item->_sock < 0) return -1; // 已关闭
if (recver_helper(item->_sock, &(item->_inbuffer)) < 0) {
item->_error_handler(item);
return -1;
}
std::vector<std::string> datagrams;
StringUtil::Split(item->_inbuffer, &datagrams, "X");
for (auto s : datagrams) {
struct data d;
StringUtil::Deserialize(s, &d._x, &d._y, &d._op);
int result = 0;
switch (d._op) {
case '+': result = d._x + d._y; break;
case '-': result = d._x - d._y; break;
case '*': result = d._x * d._y; break;
case '/':
if (d._y == 0) { std::cerr << "Error: div zero!" << std::endl; continue; }
result = d._x / d._y; break;
case '%':
if (d._y == 0) { std::cerr << "Error: mod zero!" << std::endl; continue; }
result = d._x % d._y; break;
default:
std::cerr << "operation error!" << std::endl; continue;
}
std::string response;
response += std::to_string(d._x);
response += d._op;
response += std::to_string(d._y);
response += "=";
response += std::to_string(result);
response += "X";
item->_outbuffer += response;
if (!item->_outbuffer.empty())
item->_R->EnableReadWrite(item->_sock, true, true);
}
return 0;
}
// ---------- 回调 3:写事件 ----------
int sender(EventItem* item)
{
if (item->_sock < 0) return -1;
int ret = sender_helper(item->_sock, item->_outbuffer);
if (ret == 0) {
item->_R->EnableReadWrite(item->_sock, true, false); // 发完,关写事件
} else if (ret == 1) {
item->_R->EnableReadWrite(item->_sock, true, true); // 没发完,继续关心
} else {
item->_error_handler(item);
}
return 0;
}
// ---------- 回调 4:异常 / 对端关闭 ----------
int errorer(EventItem* item)
{
int sock = item->_sock;
item->_R->DelEvent(sock); // ① 先从 epoll 摘除并取消映射
close(sock); // ② 再关闭 fd
item->_sock = -1; // ③ 置 -1,防止后续读写回调再进入
return 0;
}
// ---------- main ----------
int main(int argc, char* argv[])
{
if (argc != 2) { std::cout << "Usage: " << argv[0] << " port" << std::endl; return 1; }
int port = atoi(argv[1]);
int listen_sock = Socket::SocketCreate();
SetNonBlock(listen_sock);
Socket::SocketBind(listen_sock, port);
Socket::SocketListen(listen_sock, BACK_LOG);
Reactor R;
R.InitReactor();
EventItem item;
item._sock = listen_sock;
item._R = &R;
item.ManageCallbacks(accepter, nullptr, nullptr); // 监听套接字只关心读事件
R.AddEvent(listen_sock, EPOLLIN | EPOLLET, item);
int timeout = 1000;
while (true) R.Dispatcher(timeout);
return 0;
}
2.7 编译运行实操(CentOS7)
cpp
# 1.1 编译
g++ reactor_server.cpp -o reactor_server -std=c++11
# 1.2 启动
./reactor_server 8081

fd 3 是监听套接字。0/1/2 是标准输入/输出/错误,已占。
2、另开两个终端用 telnet 连接并发报文(每条以 X 结尾),看回包。
客户端1:
注意:4 号是 epoll 实例自己占掉的,所以第一个连接必然是 5 号。


一次发送 3 个报文、一次 recv 全收到 ------ 这正是"粘包",如果没有 2.5.2 的切包,会把
23-8X4+9X6*7当成一条报文解析错。
客户端2:


两个客户端同时在服务。这就是 Reactor 用 1 个线程 + 1 个事件循环扛住了多连接,没有为任何连接创建线程。
3、客户端 Ctrl+] 后输入 quit:



客户端断开 → Recver 读到 n == 0 → 走 Excepter → 从 epoll 模型中删除对应 fd。这一步是面试的"完整性检查点":很多人的服务器能收能发,但关闭时 fd 泄漏,跑一晚上就 EMFILE。
3. 接入线程池【必考核心】
3.1 单 Reactor 单线程痛点与线程池解决思路
当前是单 Reactor 单线程:while 循环只有一个线程,既等事件又处理事件:epoll_wait 等就绪 → Dispatcher 找 EventItem → recver(读 → 切包 → 反序列化 → 业务 → 组响应入 outbuffer → 开写事件)→ sender 发回客户端 → 回到 epoll_wait。
业务段就是 recver 里的 switch (d._op),与读写在同一线程、同一函数内同步执行。
❓问题(几乎必问):现在业务是算加减乘除,recver 一眨眼就跑完,线程立刻回到 epoll_wait,其他客户端感觉不到延迟。一旦把这段换成读数据库、做压缩、算大文件,这个线程就被 recver 占住出不来。
⚠️ 现象与后果:
cpp
客户端 A 的慢业务正在 recver 里跑(卡住)
→ Dispatcher 这一轮没结束,回不到 epoll_wait
→ 客户端 B、C 的事件即使就绪,也只能在 epoll 里排队等
→ 表现:一个客户端卡住,全体客户端都卡住
这不是 epoll 的问题,是回调里做了阻塞操作。
💡解决思路:接入线程池,IO 归 IO 线程(Reactor 线程),业务归工作线程池。
- IO 线程:读数据 → 切包 → 反序列化 → 把 "已解析好的请求" 封装成一个 Task,丢进任务队列 → 立刻回到 epoll_wait,继续接其他客户端。
- 工作线程池:从任务队列取 Task → 跑慢业务 → 结果交回 IO 线程,由 IO 线程开写事件、发回客户端。
3.2 接入线程池实操
保留原单线程版不动,线程池版单独放子目录 reactor_threadpool_server ,在 reactor_threadpool_server 里复制原单线程版各文件后增改。

| 文件 | 动作 | 内容 |
|---|---|---|
ThreadPool.hpp |
新增 | 模板线程池:任务队列 + 互斥锁 + 条件变量 + N 个工作线程 |
Task.hpp |
新增 | 任务类,Run() 跑业务并回包 |
reactor.hpp |
改动 | 加互斥锁、PostResponse 结果交回 |
reactor_server.cpp |
改动 | recver 投递任务、sender 加锁、main 建池 |
3.2.1 新增 ThreadPool.hpp
📌联动:《 Linux系统(11):线程池实现**》**4.2.1 ThreadPool.hpp
cpp
#ifndef THREADPOOL_HPP
#define THREADPOOL_HPP
#include <iostream>
#include <queue>
#include <pthread.h>
#define NUM 4 // 线程池工作线程数量
// ---------- 固定线程数模板线程池:生产者 - 消费者模型 ----------
template <class T>
class ThreadPool
{
public:
// 构造函数:初始化互斥锁、条件变量与线程数
ThreadPool(int num = NUM) : _thread_num(num)
{
pthread_mutex_init(&_mutex, nullptr);
pthread_cond_init(&_cond, nullptr);
}
// 析构函数:销毁锁与条件变量(基础版未回收工作线程,面试能说出即可)
~ThreadPool()
{
pthread_mutex_destroy(&_mutex);
pthread_cond_destroy(&_cond);
}
// ========== 核心必考:工作线程主循环(必须是静态成员函数) ==========
static void* Routine(void* arg)
{
pthread_detach(pthread_self()); // 线程分离,退出自动回收
ThreadPool* self = (ThreadPool*)arg; // 通过 this 访问非静态成员
while (true) {
pthread_mutex_lock(&self->_mutex); // 进临界区加锁
// 必须 while 判空而非 if【必考核心】
while (self->_task_queue.empty()) {
pthread_cond_wait(&self->_cond, &self->_mutex);
}
T task = self->_task_queue.front(); // 取出一个任务
self->_task_queue.pop();
pthread_mutex_unlock(&self->_mutex); // 出临界区解锁
task.Run(); // 锁外执行任务
}
}
// ========== 核心必考:创建并启动所有工作线程 ==========
void ThreadPoolInit()
{
pthread_t tid;
for (int i = 0; i < _thread_num; ++i) {
pthread_create(&tid, nullptr, Routine, this); // 必须传 this
}
}
// ========== 核心必考:任务入队 ==========
void Push(const T& task)
{
pthread_mutex_lock(&_mutex);
_task_queue.push(task);
pthread_mutex_unlock(&_mutex);
pthread_cond_signal(&_cond); // 唤醒 1 个等待线程
}
private:
std::queue<T> _task_queue; // 任务队列
int _thread_num; // 工作线程数量
pthread_mutex_t _mutex; // 互斥锁
pthread_cond_t _cond; // 条件变量
};
#endif
3.2.2 新增 Task.hpp
📌联动:《 Linux系统(11):线程池实现**》**4.2.2 Task.hpp
cpp
#ifndef TASK_HPP
#define TASK_HPP
#include <iostream>
#include <string>
#include <pthread.h>
#include "reactor.hpp"
// ---------- 任务类:线程池只通过无参 Run() 执行,与业务解耦 ----------
class Task
{
public:
Task(Reactor* R = nullptr, int sock = -1,
int x = 0, int y = 0, char op = 0)
: _R(R), _sock(sock), _x(x), _y(y), _op(op)
{}
// 工作线程调用:跑业务计算,结果交回 IO 线程发送
void Run()
{
int result = 0;
switch (_op) {
case '+': result = _x + _y; break;
case '-': result = _x - _y; break;
case '*': result = _x * _y; break;
case '/':
if (_y == 0) { std::cerr << "Error: div zero!" << std::endl; return; }
result = _x / _y; break;
case '%':
if (_y == 0) { std::cerr << "Error: mod zero!" << std::endl; return; }
result = _x % _y; break;
default:
std::cerr << "operation error!" << std::endl; return;
}
std::string resp;
resp += std::to_string(_x);
resp += _op;
resp += std::to_string(_y);
resp += "=";
resp += std::to_string(result);
resp += "X";
std::cout << "thread[" << pthread_self() << "]:" << resp << std::endl;
_R->PostResponse(_sock, resp);
}
private:
Reactor* _R; // 回指 Reactor,便于结果交回 IO 线程
int _sock; // 来源连接 fd
int _x;
int _y;
char _op;
};
#endif
3.2.3 改动 app_interface.hpp(只加一行头文件)
在原有系统头文件里补 <pthread.h>:

3.2.4 改动 reactor.hpp(加锁 + 结果交回)


3.2.5 改动 reactor_server.cpp(五处)
1)头文件 + 全局线程池指针

2)recver:业务段下沉,只封装任务入队

3)sender:发 outbuffer 时持锁,避免与工作线程追加竞态

4)main:创建并启动线程池

3.2.6 编译运行(多线程必须加 -pthread)
服务端编译运行,客户端连接并发请求 23-8X4+9X6*7X5-3X7*2X10/2X :


服务端日志出现 ≥2 个不同线程 ID ,说明请求确实被分到线程池的多个工作线程并发处理了,而不是全在事件循环(IO)线程里串行跑完。
回包顺序与发送顺序不一致,是因为并发处理,谁先算完谁先回,不保序;日志 thread\[\] 文字穿插,是因为多线程同时 cout,输出非原子;多条响应粘连成一串,协议靠 X 分隔、无换行。三者均为正常现象。