C / C++ / 系统课时

实现背压与发送队列

实现背压与发送队列

非阻塞连接不能把 send() 当成“写完即走”的同步调用:内核发送缓冲区一满,就可能只写一部分或返回 EAGAIN。本节实现每连接发送队列、高水位背压和 EPOLLOUT 动态注册,让事件循环既不阻塞,也不会无限吃内存。

学习目标

  • 解释部分写、EAGAIN 与应用层发送队列之间的关系
  • 为单个连接实现有上限的输出缓冲,并在高水位时拒绝继续入队
  • 只在确有待发送数据时监听 EPOLLOUT,队列清空后立即取消写事件

把“发送”拆成入队和排空

非阻塞 send() 只承诺“尽量写”。一次调用可能返回小于请求长度的正数,也可能以 EAGAIN/EWOULDBLOCK 告诉你当前没有发送空间。因此业务代码不应循环等待“直到全部写完”,否则事件循环会在一个慢连接上耗尽时间片。

更稳妥的职责划分是:业务响应先进入该连接自己的输出队列;Reactor 在套接字可写时调用排空函数;未写完的尾部继续留在队列中。这样慢客户端只拖慢自己的连接,不会直接阻塞其他连接。

非阻塞发送队列与背压流程

用高水位把内存变成有限资源

高水位不是“队列满了再想办法”,而是入队前的硬约束。若当前待发送字节数为 queued,新响应长度为 n,只有 queued + n <= HIGH_WATER 才允许入队。超过阈值后可以暂时关闭该连接的读兴趣,让上游请求自然停下来;若协议或业务不允许长时间积压,也可以直接拒绝新响应或关闭异常连接。

写事件也要按需注册。队列从空变为非空时加入 EPOLLOUT;队列重新变空时移除它。若始终监听可写事件,大多数套接字会长期处于“可写”状态,epoll_wait() 会被无意义地频繁唤醒,形成忙循环。

主示例:维护队列并按需监听写事件

下面的 Linux 示例使用 socketpair() 构造一个本地连接。第一个 48 KiB 响应进入队列,随后 32 KiB 响应因超过 64 KiB 高水位被拒绝;事件循环只在有积压时监听 EPOLLOUT,并持续排空队列。compact_out() 负责在部分发送后复用缓冲区前部空间。

c
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>

enum { HIGH_WATER = 64 * 1024, CHUNK = 8 * 1024 };

typedef struct {
    int fd;
    unsigned char out[HIGH_WATER];
    size_t off;
    size_t len;
} Conn;

static int set_nonblock(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    return flags < 0 ? -1 : fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

static size_t queued(const Conn *c) {
    return c->len - c->off;
}

static void compact_out(Conn *c) {
    if (c->off == 0) return;
    memmove(c->out, c->out + c->off, queued(c));
    c->len = queued(c);
    c->off = 0;
}

static int queue_bytes(Conn *c, const void *data, size_t n) {
    if (queued(c) + n > HIGH_WATER) return -1;
    compact_out(c);
    memcpy(c->out + c->len, data, n);
    c->len += n;
    return 0;
}

static int flush_out(Conn *c) {
    while (queued(c) > 0) {
        ssize_t n = send(c->fd, c->out + c->off, queued(c), MSG_NOSIGNAL);
        if (n > 0) {
            c->off += (size_t)n;
            continue;
        }
        if (n < 0 && errno == EINTR) continue;
        if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return 1;
        return -1;
    }
    c->off = c->len = 0;
    return 0;
}

static int update_interest(int epfd, Conn *c) {
    struct epoll_event ev = {
        .events = EPOLLIN | (queued(c) ? EPOLLOUT : 0),
        .data.ptr = c
    };
    return epoll_ctl(epfd, EPOLL_CTL_MOD, c->fd, &ev);
}

int main(void) {
    int sv[2];
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) < 0) return 1;
    if (set_nonblock(sv[0]) < 0 || set_nonblock(sv[1]) < 0) return 1;

    int sndbuf = 4096;
    setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));

    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd < 0) return 1;

    Conn c = {.fd = sv[0]};
    struct epoll_event ev = {.events = EPOLLIN, .data.ptr = &c};
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, c.fd, &ev) < 0) return 1;

    unsigned char a[48 * 1024];
    unsigned char b[32 * 1024];
    memset(a, 'A', sizeof(a));
    memset(b, 'B', sizeof(b));

    if (queue_bytes(&c, a, sizeof(a)) == 0)
        printf("accepted %zu bytes, queued=%zu\n", sizeof(a), queued(&c));

    if (queue_bytes(&c, b, sizeof(b)) < 0)
        printf("rejected %zu bytes at high water=%d\n", sizeof(b), HIGH_WATER);

    if (update_interest(epfd, &c) < 0) return 1;

    size_t peer_received = 0;
    unsigned char tmp[CHUNK];
    while (queued(&c) > 0 || peer_received < sizeof(a)) {
        struct epoll_event events[4];
        int n = epoll_wait(epfd, events, 4, 1000);
        if (n < 0 && errno == EINTR) continue;
        if (n < 0) return 1;

        for (int i = 0; i < n; ++i) {
            if (events[i].events & EPOLLOUT) {
                if (flush_out(&c) < 0) return 1;
                if (update_interest(epfd, &c) < 0) return 1;
            }
        }

        for (;;) {
            ssize_t r = recv(sv[1], tmp, sizeof(tmp), 0);
            if (r > 0) {
                peer_received += (size_t)r;
                continue;
            }
            if (r < 0 && errno == EINTR) continue;
            if (r < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) break;
            break;
        }
    }

    printf("drained, queued=%zu, peer_received=%zu\n", queued(&c), peer_received);
    close(epfd);
    close(sv[0]);
    close(sv[1]);
    return 0;
}

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

bash
gcc -O2 -Wall -Wextra backpressure.c -o backpressure
./backpressure

预期输出:

text
accepted 49152 bytes, queued=49152
rejected 32768 bytes at high water=65536
drained, queued=0, peer_received=49152

示例中的发送缓冲区被主动调小,只是为了更容易触发部分写;不同内核上的具体单次 send() 长度可能不同,但最终接收字节数和高水位判断应一致。

把背压接回读取路径

真正的服务器还要把发送积压反向传递到输入侧。常见策略是在 queued 达到软阈值时暂停该连接的 EPOLLIN,降到恢复阈值后再打开,形成滞回区,避免读事件在阈值附近频繁开关。硬高水位则作为最后保护线,禁止继续扩大队列。

需要特别避免两类错误:一是 EAGAIN 后丢弃未发送尾部,造成响应截断;二是队列已经为空却继续监听 EPOLLOUT,造成 CPU 空转。背压的核心不是“尽量多缓存”,而是让每个连接的内存占用、写事件和上游读取速度形成一个有界闭环。

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

目录与阅读设置

阅读设置

17

记录一个想法

实现背压与发送队列

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

登录哪都通