Reactor 是一种事件驱动的服务器组织方式:一个或多个事件循环(event loop)监听一批 fd,哪个 fd 就绪,就调用它对应的处理函数。它不需要为每条连接创建一个线程,连接的状态、缓冲区和回调都收在一个对象里。

它和直接写 epoll 的区别不在系统调用,而在职责划分。裸 epoll 的循环里通常塞满“是不是监听 fd”“有没有 EPOLLIN”“有没有 EPOLLOUT”的分支;Reactor 把“谁就绪”交给多路复用器,把“就绪了做什么”封装成回调,循环只做分发。

打地鼠:锤子不往每个洞里捅,只等某只地鼠冒头。事件驱动省下的是“挨个检查所有洞”的时间,不是处理事件本身的时间

这张图也提示了 Reactor 的成本边界:如果每个洞里的地鼠一直露头,锤子还是每轮都得落下。对应到代码里,就是不要把 EPOLLOUT 常驻——发送缓冲区没满时它几乎永远成立,事件循环会空转。

一个连接是一个对象

Reactor 里的 Connection 至少装这些字段:fd、关注的事件位、接收缓冲区、发送缓冲区、三个回调(读、写、异常),以及指回服务器的指针。

class Connection;
class Reactor;
 
using Callback = std::function<void(Connection *)>;
 
struct Connection {
    int fd;
    uint32_t events;          /* 当前注册进 epoll 的事件 */
    std::string in;           /* 收到但还没切出完整报文的字节 */
    std::string out;          /* 还没发给内核的字节 */
    bool closing;             /* 已排队等待删除 */
    Reactor *owner;
 
    Callback onRead;
    Callback onWrite;
    Callback onError;
 
    Connection(int f, Reactor *r)
        : fd(f), events(EPOLLIN), closing(false), owner(r) {}
};

Connection 不知道业务协议。监听 fd 和新连接 fd 用的是同一个类型,区别只在注册的回调:监听 fd 的读回调负责 accept,新连接的读回调负责 recv。工厂函数就是把“这类连接关心什么事件、需要哪些回调”集中到一处的地方。

事件循环:等、分发、清理

下面是一份能编译运行的单 Reactor 回显服务器。它把监听 fd 也做成 Connection,事件循环里不需要特判“是不是监听 fd”,分发完全按回调走。

#define _GNU_SOURCE
 
/* reactor_echo.cpp
 * 编译:g++ -std=c++17 -Wall -Wextra reactor_echo.cpp -o reactor_echo
 * 运行:./reactor_echo,然后 nc 127.0.0.1 8888
 */
#include <arpa/inet.h>
#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <fcntl.h>
#include <functional>
#include <iostream>
#include <netinet/in.h>
#include <string>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#include <unordered_map>
#include <vector>
 
struct Connection;
class Reactor;
 
using Callback = std::function<void(Connection *)>;
 
struct Connection {
    int fd;
    uint32_t events;
    std::string in;
    std::string out;
    bool closing;
    Reactor *owner;
    Callback onRead;
    Callback onWrite;
    Callback onError;
 
    Connection(int f, Reactor *r)
        : fd(f), events(EPOLLIN), closing(false), owner(r) {}
};
 
class Reactor {
public:
    Reactor() : epfd_(epoll_create1(EPOLL_CLOEXEC)), lfd_(-1) {}
 
    ~Reactor()
    {
        for (auto &kv : conns_) {
            close(kv.first);
            delete kv.second;
        }
        if (lfd_ >= 0)
            close(lfd_);
        if (epfd_ >= 0)
            close(epfd_);
    }
 
    bool start(uint16_t port)
    {
        lfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (lfd_ < 0) {
            perror("socket");
            return false;
        }
 
        int yes = 1;
        setsockopt(lfd_, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
 
        struct sockaddr_in addr;
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
        if (bind(lfd_, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
            perror("bind");
            return false;
        }
        if (listen(lfd_, 128) < 0) {
            perror("listen");
            return false;
        }
        setNonBlock(lfd_);
 
        Connection *listener = new Connection(lfd_, this);
        listener->onRead = [this](Connection *) { acceptAll(); };
        listener->onError = [this](Connection *c) { removeLater(c); };
        return addConn(listener);
    }
 
    void run()
    {
        struct epoll_event evs[64];
 
        for (;;) {
            int n = epoll_wait(epfd_, evs, 64, -1);
            if (n < 0) {
                if (errno == EINTR)
                    continue;
                perror("epoll_wait");
                break;
            }
 
            for (int i = 0; i < n; ++i) {
                Connection *c = static_cast<Connection *>(evs[i].data.ptr);
                uint32_t events = evs[i].events;
 
                if (events & EPOLLIN)
                    c->onRead(c);
                if (events & EPOLLOUT)
                    c->onWrite(c);
                if (events & (EPOLLERR | EPOLLHUP))
                    c->onError(c);
            }
 
            reap();
        }
    }
 
private:
    static void setNonBlock(int fd)
    {
        int fl = fcntl(fd, F_GETFL);
        if (fl < 0)
            return;
        fcntl(fd, F_SETFL, fl | O_NONBLOCK);
    }
 
    bool addConn(Connection *c)
    {
        struct epoll_event ev;
        memset(&ev, 0, sizeof(ev));
        ev.events = c->events;
        ev.data.ptr = c;
 
        if (epoll_ctl(epfd_, EPOLL_CTL_ADD, c->fd, &ev) < 0) {
            perror("epoll_ctl ADD");
            delete c;
            return false;
        }
        conns_[c->fd] = c;
        return true;
    }
 
    void updateEvents(Connection *c)
    {
        struct epoll_event ev;
        memset(&ev, 0, sizeof(ev));
        ev.events = c->events;
        ev.data.ptr = c;
        if (epoll_ctl(epfd_, EPOLL_CTL_MOD, c->fd, &ev) < 0)
            perror("epoll_ctl MOD");
    }
 
    void acceptAll()
    {
        for (;;) {
            int fd = accept(lfd_, NULL, NULL);
            if (fd < 0) {
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                    break;
                if (errno == EINTR)
                    continue;
                perror("accept");
                break;
            }
 
            setNonBlock(fd);
            Connection *c = new Connection(fd, this);
            c->onRead = [this](Connection *x) { handleRead(x); };
            c->onWrite = [this](Connection *x) { handleWrite(x); };
            c->onError = [this](Connection *x) { removeLater(x); };
            if (!addConn(c))
                close(fd);
        }
    }
 
    void handleRead(Connection *c)
    {
        if (c->closing)
            return;
 
        char buf[4096];
        for (;;) {
            ssize_t n = recv(c->fd, buf, sizeof(buf), 0);
            if (n > 0) {
                c->in.append(buf, (size_t)n);
                c->out.append(buf, (size_t)n);   /* 回显:收到什么就排进发送缓冲 */
                continue;
            }
            if (n == 0) {
                removeLater(c);
                return;
            }
            if (errno == EINTR)
                continue;
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                break;
            removeLater(c);
            return;
        }
 
        if (!c->out.empty())
            handleWrite(c);
    }
 
    void handleWrite(Connection *c)
    {
        if (c->closing)
            return;
 
        while (!c->out.empty()) {
            ssize_t n = send(c->fd, c->out.data(), c->out.size(), MSG_NOSIGNAL);
            if (n > 0) {
                c->out.erase(0, (size_t)n);
                continue;
            }
            if (errno == EINTR)
                continue;
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                break;
            removeLater(c);
            return;
        }
 
        if (!c->out.empty()) {
            if (!(c->events & EPOLLOUT)) {
                c->events |= EPOLLOUT;       /* 发不动了,临时关心写事件 */
                updateEvents(c);
            }
        } else {
            if (c->events & EPOLLOUT) {
                c->events &= ~EPOLLOUT;      /* 发空了,立刻摘掉 */
                updateEvents(c);
            }
        }
    }
 
    void removeLater(Connection *c)
    {
        if (c->closing)
            return;
        c->closing = true;
        dead_.push_back(c);
    }
 
    void reap()
    {
        for (Connection *c : dead_) {
            epoll_ctl(epfd_, EPOLL_CTL_DEL, c->fd, NULL);
            conns_.erase(c->fd);
            close(c->fd);
            if (c->fd == lfd_)
                lfd_ = -1;               /* 监听 fd 已经关掉,析构时不再重复 close */
            delete c;
        }
        dead_.clear();
    }
 
    int epfd_;
    int lfd_;
    std::unordered_map<int, Connection *> conns_;
    std::vector<Connection *> dead_;
};
 
int main()
{
    Reactor r;
    if (!r.start(8888))
        return 1;
    r.run();
    return 0;
}

这份代码把 Reactor 的主循环压到十几行:epoll_wait 拿到就绪列表,按 data.ptr 找到 Connection,按事件位调对应回调,循环末尾统一回收。业务代码增加时,循环本身不改。

三个回调的边界

handleRead 只做“把字节搬进接收缓冲区”。它必须循环 recv 到 EAGAIN,否则 ET 模式下同一批数据只通知一次,剩下没读的部分要等下一次状态跳变,而那次跳变可能永远不来。非阻塞 fd 是这条循环能退出的前提。

handleWrite 只做“把发送缓冲区交给内核”。send 不保证一次发完,对端读得慢、窗口变小、发送缓冲区满,都会只吐出一部分。已经交给内核的字节从 out 里删掉,剩下的留着;EAGAIN 表示这一轮到头了,不是错误。

removeLater 只标记,不删除。回调栈上还可能有人持有这个 Connection,同一批 epoll_wait 结果里也可能还有它的事件。真正删除放到 reap:先 EPOLL_CTL_DEL,从映射表里 erase,再 close,最后 delete。到这一步,没有任何回调还持有它。

课件里的 Excepter 直接在回调里执行“移除、关闭、delete conn”,会留下悬垂指针:分发器手里的 Connection*、data.ptr、同批事件里的后续回调都可能继续访问这块已经释放的内存。把删除延后到一轮分发结束,是 Reactor 里必须守住的一条纪律。muduo、libevent 里都有类似机制,名字可能叫 pending close 或 deferred delete。

单 Reactor、单 Reactor 多线程、主从 Reactor

三种常见形态的差别在于“哪个线程干什么”。

单 Reactor 单线程:一个线程跑一个 epoll_wait,accept、读、业务计算、写、清理全在这条循环里。结构最简单,没有锁,也没有跨线程交接。缺点是任何一步慢了,所有连接一起等。业务里有磁盘 IO、复杂计算、数据库访问时,这条模型撑不住。

单 Reactor 多线程:仍然只有一个事件循环负责 IO,但把业务处理丢给线程池。IO 线程读到一个完整报文,打包成任务投递出去;工作线程算完,把响应交回 IO 线程发送。连接和缓冲区只在 IO 线程里碰,工作线程不直接读写 socket。代价是多了一次任务队列和线程同步,收益是把 CPU 密集的业务从事件循环里挪走。

主从 Reactor:主 Reactor 只负责监听和 accept,把新连接分给若干从 Reactor;每个从 Reactor 在自己的线程里跑一个独立的事件循环,管理分到它的连接。连接的读、写、业务、关闭全在从 Reactor 的线程里完成,所以每条连接不需要加锁。这就是 One Thread One Loop(OTOL):一个线程一个 loop,连接跟着 loop 走。

主从 Reactor 用管道分发连接:Master 的 listensock 收到新连接后,把 fd 写进某个子进程的管道;Slave 的 pipe[0] 被封装成 Connection 加进自己的 Reactor,回调从管道里读出 fd 并登记

这张图里主 Reactor 只做 accept 和分发,从 Reactor 负责连接的完整生命周期。图上的文字还标出了一个边界:accept 本身有并发问题,多个执行流同时 accept 同一条监听 fd,只有一个能拿到连接,其他的会被唤醒又失败,这就是惊群。

OTOL 的关键纪律是“连接不跨线程”。只要一条连接的所有读写、所有缓冲区修改都发生在拥有它的那个 loop 线程里,out 缓冲区就不需要锁,也不会有两个线程同时 send 同一条连接。

把 loop 放到进程里也成立:每个进程管理自己的一批连接和 fd,集合互不重叠;每条连接的读、写、关闭由所属 Reactor 完整处理,不需要别的进程插手,也就不会出现同一批字节被两个执行流分段处理、顺序错乱的问题。代价是进程之间不能共享连接状态,分发和回收都要走进程间通信。

管道、eventfd 与跨线程唤醒

主 Reactor 把连接分给从 Reactor 时,要解决“怎么把新 fd 交给另一个线程,并叫醒它”。

线程之间共享 fd 表,主线程 accept 出来的 fd,工作线程直接就能用,不需要“传递”。课件那句“多线程是可以共享文件 fd 的……通过管道传递给每一个子进程”把线程和进程混在了一起。进程之间 fd 表是隔离的,普通管道只能传字节,不能传 fd 编号;要把一个 fd 交给另一个进程,得用 UNIX domain socket 配合 SCM_RIGHTS 辅助数据,接收方拿到的是一个指向同一份打开文件描述的新 fd。

线程之间则简单得多:共享一个队列,把 fd 或连接指针放进去,然后叫醒目标线程。叫醒不能靠改一个布尔标志,目标线程正阻塞在 epoll_wait 里,看不到标志。需要一个能被 epoll 监视的 fd,写它一下,epoll_wait 就会返回。管道可以,eventfd 更轻。

eventfd 做主从通知:Master 把新连接放进共享队列,再往各从 Reactor 的 eventfd 写一下;Slave 的 read_eventfd 回调被唤醒后,从队列里取出 fd 并登记到自己的 Reactor

图里那个共享队列是关键。eventfd 只传“有事发生”,不传“是什么事”。被唤醒的线程仍然要去队列里取任务,队列本身该怎么加锁还是怎么加。

#include <stdint.h>
#include <sys/eventfd.h>
#include <unistd.h>
 
int efd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
 
uint64_t one = 1;
write(efd, &one, sizeof(one));    /* 通知方:计数器加一,唤醒等待者 */
 
uint64_t value;
read(efd, &value, sizeof(value)); /* 被唤醒方:默认模式读走当前总值并清零 */

eventfd 的内核对象是一个 64 位计数器。默认模式下,计数器非零时一次 read 返回 8 字节的当前值,然后把计数器清零;计数器为 0 时,阻塞模式会睡,非阻塞模式返回 EAGAIN。加 EFD_SEMAPHORE 才变成“每次读返回 1、计数器减 1”。

课件那段演示的输出注释是错的:先写 1 再写 2,计数器是 3;第一次 read 返回 3 并清零,后面两次在非阻塞模式下返回 -1 和 EAGAIN,不可能返回 0。屏幕上打印的两个 0 是变量在 read 之前被手动清零的残留值,不是读到的结果。

eventfd 适合线程间、进程间的“门铃”通知,不适合传具体消息。它比管道少一次数据拷贝,内核开销也更小;EFD_CLOEXEC 保证 exec 时自动关闭,EFD_NONBLOCK 避免读空时阻塞。

Reactor 与 Proactor 的界线

Reactor 提供的是“就绪通知”:内核说这个 fd 现在可以读了,真正的 read 由用户线程发起,数据拷贝也由用户线程完成。Proactor 提供的是“完成通知”:用户把“读多少、读到哪、完成后调谁”一次性交给内核,内核完成等待和拷贝,再回调用户。Windows 的 IOCP 是典型 Proactor;Linux 原生的 io_uring 也属于完成通知模型。

所以 epoll 加自己的 read 是标准 Reactor,不能叫异步 IO。异步的是通知机制,不是数据搬运。把“用了 epoll”说成“用了异步 IO”,混淆的正是这两层。

工程实现上的几条硬约束

  • 监听 fd 和新连接都要非阻塞。监听 fd 非阻塞是为了 accept 能循环到 EAGAIN,一批连接同时到达时不会只接一个;新连接非阻塞是为了读写循环有 EAGAIN 这个出口。
  • EPOLLOUT 按需开关。只在发送缓冲区非空时注册,发空立刻用 EPOLL_CTL_MOD 摘掉。常驻写事件会把事件循环变成忙等。
  • 关闭延后。回调里只标记,统一在一轮分发结束后 DEL、erase、close、delete。
  • 连接不跨线程。OTOL 下每条连接只属于一个 loop,缓冲区不加锁;跨线程只传任务,不传连接指针供两边同时操作。
  • EPOLL_CTL_DEL 不关闭 fd。课件里“epoll 删除的时候其实就已经关闭 socket 了”这句是错的,DEL 只把 fd 从兴趣列表摘掉,close 必须单独调用。
  • accept 成功返回非负 fd,0 也是合法值。课件用 if (sockfd > 0) 判断成功,会把 fd 0 当成失败并泄漏连接,应写成 >= 0。
  • 默认用 LT。LT 下读不完下次还会被提醒,写不完下次也还会被提醒,代码不容易卡死。确认需要减少重复通知,再换 ET,并按 ET 的规则读到 EAGAIN。

muduo 这类库把上述约束做成了固定结构:主线程 accept 后按轮转分给 sub loop;每个 loop 一个线程;跨线程调用通过 runInLoop/queueInLoop 投递,并用 eventfd 唤醒;TcpConnection 用 shared_ptr 管理生命周期,关闭走 pending 队列;默认 LT,只有在明确需要时才开 ET。这些做法不是框架特有的技巧,而是 Reactor 在多线程环境里避开悬垂指针和忙等的必要条件。