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() 负责在部分发送后复用缓冲区前部空间。
#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 后编译运行:
gcc -O2 -Wall -Wextra backpressure.c -o backpressure
./backpressure预期输出:
accepted 49152 bytes, queued=49152
rejected 32768 bytes at high water=65536
drained, queued=0, peer_received=49152示例中的发送缓冲区被主动调小,只是为了更容易触发部分写;不同内核上的具体单次 send() 长度可能不同,但最终接收字节数和高水位判断应一致。
把背压接回读取路径
真正的服务器还要把发送积压反向传递到输入侧。常见策略是在 queued 达到软阈值时暂停该连接的 EPOLLIN,降到恢复阈值后再打开,形成滞回区,避免读事件在阈值附近频繁开关。硬高水位则作为最后保护线,禁止继续扩大队列。
需要特别避免两类错误:一是 EAGAIN 后丢弃未发送尾部,造成响应截断;二是队列已经为空却继续监听 EPOLLOUT,造成 CPU 空转。背压的核心不是“尽量多缓存”,而是让每个连接的内存占用、写事件和上游读取速度形成一个有界闭环。