Linux网络(12):Reactor 模式

💬 :如果你在阅读过程中有任何疑问或想要进一步探讨的内容,欢迎在评论区畅所欲言!我们一起学习、共同成长~!

👍 :如果你觉得这篇文章还不错,不妨顺手点个赞、加入收藏,并分享给更多的朋友噢~!


引言 :上一章《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 处理一次事件的完整工作流程:

  1. 注册:应用向初始分发器注册事件处理器,登记 fd、关心的 IO 事件、就绪后执行的回调函数。
  2. 等待:启动初始分发器的事件循环,由同步事件分离器(epoll/select/poll)阻塞等待这些 fd 上的 IO 事件就绪。
  3. 查找:同步事件分离器检测到某个 fd 就绪,通知初始分发器,分发器以就绪的 fd 为索引,匹配对应的事件处理器。
  4. 派发:初始分发器调用事件处理器内注册好的回调方法,处理完继续等待。

查找派发如图:

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 服务器工作流程如下:

  1. 注册:把 fd、关心事件、回调打包注册进 Reactor;启动时注册监听 fd;accepter 拿到新连接后,用 AddEvent 完成新连接注册。
  2. 等待:Reactor 启动派发事件循环,epoll_wait 阻塞等待 fd 就绪。
  3. 查找:epoll 上报就绪 fd,Reactor 通过 fd 索引找到对应的 EventItem。
  4. 派发:执行 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 类中有两个成员:

  1. 一个 _epfd 成员,记录 epoll 模型对应的 fd。
  2. 一个 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 分隔、无换行。三者均为正常现象。

相关推荐
思想觉悟1 小时前
Android启动流程之点rc文件
android·linux·面试
kyle~12 小时前
嵌入式 SoC 系统
linux·c++·嵌入式·计算系统
其实防守也摸鱼14 小时前
用 Claude Code 重构遗留系统:从评估到落地的完整指南
前端·网络·人工智能·chrome·安全·重构
人生!?14 小时前
Linux 从入门到进阶 | 基础语法
linux·笔记·教程
优化Henry15 小时前
LTE 站点 S1 链路反复闪断导致小区频闪退服故障排查
运维·网络·学习·信息与通信·tdd
心之王者71616 小时前
Linux 进程信号:从产生、阻塞到捕捉与子进程回收
linux·服务器·网络
.痞老板.16 小时前
java ee--网络编程套接字
网络·java-ee·php
AndreaYYmm16 小时前
日志里 grep 到 Fail 就判失败?这六个假阳性我全踩过
linux·shell
2401_8685347816 小时前
逻辑网络设计
网络·python