C / C++ / 系统课时

设计 Reactor 与线程池协作

设计 Reactor 与线程池协作

Reactor 适合负责就绪事件和连接状态,线程池适合执行可能耗时的业务计算。真正困难的是两者的交界:如果工作线程直接修改连接对象、调用 epoll_ctl() 或发送数据,就会把连接生命周期变成跨线程共享状态。本节用任务消息和完成消息切断这种竞态。

学习目标

  • 划分 Reactor 线程与工作线程的职责边界
  • 用任务队列、完成队列和 eventfd 建立安全的跨线程通信
  • 用连接 ID 与 generation 校验过期任务,避免文件描述符复用导致错写

让连接状态只归 Reactor 所有

一个可靠的约束是:只有 Reactor 线程可以读写连接对象、关闭文件描述符、修改 epoll 兴趣集和维护发送队列。工作线程拿到的不是 Conn *,而是一份不可变任务,例如请求参数、连接 ID、generation 和业务数据。

任务完成后,工作线程也不直接 send()。它把结果写入完成队列,再向 eventfd 写入一个计数。Reactor 已经把该 eventfd 注册到 epoll,被唤醒后批量取出完成消息,重新核对连接身份,再把响应加入对应发送队列。

Reactor 与线程池消息协作结构

用 generation 对抗连接复用

只传文件描述符还不够。连接关闭后,Linux 很快可能把相同的 fd 数字分配给新连接;旧任务稍后完成时,如果只按 fd 查找,就可能把旧响应发送给新客户端。

因此连接表通常为每次新连接分配稳定 ID,并维护递增的 generation。提交任务时把二者一起复制进去;完成消息回来后,Reactor 只有在“连接仍存在且 generation 完全一致”时才接受结果。关闭并重建连接会改变 generation,旧任务自然失效。

主示例:eventfd 唤醒 Reactor

下面的程序启动两个工作线程。Reactor 投递三个计算任务,其中一个故意携带过期 generation。Worker 只从任务队列取值并计算平方,不接触连接表;完成后把结果放入完成队列并写 eventfd。主线程通过 epoll_wait() 收到唤醒,完成连接校验和状态更新。

c
#define _GNU_SOURCE
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <unistd.h>

enum { QCAP = 16, WORKERS = 2 };

typedef struct {
    int conn_id;
    unsigned generation;
    int value;
} Task;

typedef struct {
    int conn_id;
    unsigned generation;
    int result;
} Completion;

typedef struct {
    Task items[QCAP];
    int head, tail, count, stopping;
    pthread_mutex_t mu;
    pthread_cond_t cv;
} TaskQueue;

typedef struct {
    Completion items[QCAP];
    int head, tail, count;
    pthread_mutex_t mu;
} CompletionQueue;

typedef struct {
    unsigned generation;
    int last_result;
} Conn;

static TaskQueue tasks = {
    .mu = PTHREAD_MUTEX_INITIALIZER,
    .cv = PTHREAD_COND_INITIALIZER
};
static CompletionQueue completions = {
    .mu = PTHREAD_MUTEX_INITIALIZER
};
static int wake_fd;

static void push_task(Task t) {
    pthread_mutex_lock(&tasks.mu);
    tasks.items[tasks.tail] = t;
    tasks.tail = (tasks.tail + 1) % QCAP;
    tasks.count++;
    pthread_cond_signal(&tasks.cv);
    pthread_mutex_unlock(&tasks.mu);
}

static int pop_task(Task *t) {
    pthread_mutex_lock(&tasks.mu);
    while (tasks.count == 0 && !tasks.stopping)
        pthread_cond_wait(&tasks.cv, &tasks.mu);

    if (tasks.count == 0 && tasks.stopping) {
        pthread_mutex_unlock(&tasks.mu);
        return 0;
    }

    *t = tasks.items[tasks.head];
    tasks.head = (tasks.head + 1) % QCAP;
    tasks.count--;
    pthread_mutex_unlock(&tasks.mu);
    return 1;
}

static void push_completion(Completion c) {
    pthread_mutex_lock(&completions.mu);
    completions.items[completions.tail] = c;
    completions.tail = (completions.tail + 1) % QCAP;
    completions.count++;
    pthread_mutex_unlock(&completions.mu);

    uint64_t one = 1;
    if (write(wake_fd, &one, sizeof(one)) != sizeof(one)) abort();
}

static int pop_completion(Completion *c) {
    pthread_mutex_lock(&completions.mu);
    if (completions.count == 0) {
        pthread_mutex_unlock(&completions.mu);
        return 0;
    }

    *c = completions.items[completions.head];
    completions.head = (completions.head + 1) % QCAP;
    completions.count--;
    pthread_mutex_unlock(&completions.mu);
    return 1;
}

static void *worker_main(void *arg) {
    (void)arg;
    Task t;
    while (pop_task(&t)) {
        Completion c = {
            .conn_id = t.conn_id,
            .generation = t.generation,
            .result = t.value * t.value
        };
        push_completion(c);
    }
    return NULL;
}

int main(void) {
    Conn conns[2] = {
        {.generation = 1},
        {.generation = 1}
    };

    wake_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (wake_fd < 0 || epfd < 0) return 1;

    struct epoll_event ev = {.events = EPOLLIN, .data.fd = wake_fd};
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, wake_fd, &ev) < 0) return 1;

    pthread_t tids[WORKERS];
    for (int i = 0; i < WORKERS; ++i)
        pthread_create(&tids[i], NULL, worker_main, NULL);

    push_task((Task){.conn_id = 0, .generation = 1, .value = 7});
    push_task((Task){.conn_id = 1, .generation = 1, .value = 9});
    push_task((Task){.conn_id = 0, .generation = 0, .value = 5});

    int handled = 0;
    while (handled < 3) {
        struct epoll_event events[4];
        int n = epoll_wait(epfd, events, 4, -1);
        if (n < 0) return 1;

        for (int i = 0; i < n; ++i) {
            if (events[i].data.fd != wake_fd) continue;

            uint64_t notifications;
            if (read(wake_fd, &notifications, sizeof(notifications)) < 0)
                return 1;

            Completion c;
            while (pop_completion(&c)) {
                handled++;
                Conn *conn = &conns[c.conn_id];

                if (conn->generation != c.generation) {
                    printf("drop stale completion: conn=%d gen=%u\n",
                           c.conn_id, c.generation);
                    continue;
                }

                // 只有 Reactor 修改连接状态;真实服务器会在这里入发送队列。
                conn->last_result = c.result;
                printf("apply completion: conn=%d gen=%u result=%d\n",
                       c.conn_id, c.generation, c.result);
            }
        }
    }

    pthread_mutex_lock(&tasks.mu);
    tasks.stopping = 1;
    pthread_cond_broadcast(&tasks.cv);
    pthread_mutex_unlock(&tasks.mu);

    for (int i = 0; i < WORKERS; ++i)
        pthread_join(tids[i], NULL);

    close(epfd);
    close(wake_fd);
    return 0;
}

保存为 reactor_pool.c 后编译运行:

bash
gcc -O2 -Wall -Wextra -pthread reactor_pool.c -o reactor_pool
./reactor_pool

预期输出包含以下三行;两个工作线程并发执行,因此行的先后顺序可能不同:

text
apply completion: conn=0 gen=1 result=49
apply completion: conn=1 gen=1 result=81
drop stale completion: conn=0 gen=0

eventfd 的价值在于把“线程池有结果了”转换为普通 fd 可读事件,使 Reactor 不需要轮询完成队列。生产代码还应给固定容量队列补上满队列策略,避免工作速度持续落后时把内存压力从连接队列转移到任务队列。

明确哪些操作不能跨线程

把边界固定后,并发设计会简单很多:Reactor 负责 accept、recv、协议状态、连接关闭、epoll_ctl() 和发送队列;Worker 负责 CPU 密集计算、阻塞式存储访问或其他不依赖连接对象的任务。Worker 返回的是结果消息,而不是“请替我操作这个 Conn *”。

若业务必须取消任务,也应发送“取消意图”或在共享任务状态上使用明确的原子协议,而不是让多个线程抢着关闭同一 fd。只要连接状态保持单线程所有、跨线程只传值对象,并在回程校验 conn_id + generation,Reactor 与线程池就能在保持吞吐的同时,把最难处理的生命周期竞态压缩到清晰的消息边界上。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

设计 Reactor 与线程池协作

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通