操作系统 / 系统课时
用背压限制慢客户端占用
用背压限制慢客户端占用
事件驱动服务器最危险的慢连接,不是“收不到数据”,而是应用持续产生响应、内核却迟迟发不出去。本篇用高低水位线限制单连接待发送数据:积压过高时暂停读取,回落后恢复;超过硬上限则主动断开,从而把内存和事件循环开销控制在可预期范围内。
学习目标
- 识别发送速度低于业务产出速度时,用户态输出队列为何会持续增长。
- 用高水位、低水位和硬上限设计稳定的背压策略。
- 在
epoll中动态关闭和恢复EPOLLIN,避免慢客户端拖累其他连接。
慢客户端为什么会放大资源占用
非阻塞 send() 返回 EAGAIN 时,说明当前不能继续写入套接字发送缓冲区。此时应用只能把尚未发送的数据留在用户态队列中。如果业务仍继续读取请求并生成响应,队列就会越积越多,单个客户端最终可能占用大量内存,并反复触发可写事件处理。
背压的关键不是“让网络变快”,而是在输出积压达到阈值后停止继续制造更多输出。最常用的做法是给每个连接维护待发送字节数,并用三个阈值约束它。

用高低水位线避免频繁抖动
只设一个阈值会导致队列在阈值附近反复暂停和恢复读取。高低水位形成“滞回区间”:达到高水位才暂停,必须下降到更低的低水位才恢复。
| 阈值 | 本例取值 | 动作 |
|---|---|---|
| 低水位 | 8 KiB | 已暂停且积压降到此值以下时恢复读取 |
| 高水位 | 32 KiB | 暂停该连接的读取事件 |
| 硬上限 | 60 KiB | 拒绝继续排队并关闭连接 |
高水位应明显低于硬上限,给已经在处理中的响应和协议开销留出余量。硬上限不是流量调节器,而是最后一道资源保护线。
把背压接入 epoll
下面是一个最小可运行的非阻塞 echo 服务器。每个连接有固定输出缓冲区;当积压达到高水位时,从兴趣集合中移除 EPOLLIN,只有待发送数据降到低水位后才恢复读取。
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <unistd.h>
#define PORT 9090
#define MAX_EVENTS 64
#define OUT_CAP 65536
#define HIGH_WATER 32768
#define LOW_WATER 8192
#define HARD_LIMIT 60000
typedef struct {
int fd;
size_t begin;
size_t end;
int read_paused;
char out[OUT_CAP];
} Conn;
static int epfd;
static int listener_tag;
static size_t pending(const Conn *c) {
return c->end - c->begin;
}
static int update_interest(Conn *c) {
struct epoll_event ev = {.events = EPOLLRDHUP, .data.ptr = c};
if (!c->read_paused) ev.events |= EPOLLIN;
if (pending(c) > 0) ev.events |= EPOLLOUT;
return epoll_ctl(epfd, EPOLL_CTL_MOD, c->fd, &ev);
}
static void close_conn(Conn *c) {
printf("client fd=%d closed\n", c->fd);
close(c->fd);
free(c);
}
static int flush_output(Conn *c) {
while (pending(c) > 0) {
ssize_t n = send(c->fd, c->out + c->begin, pending(c), MSG_NOSIGNAL);
if (n > 0) {
c->begin += (size_t)n;
} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
break;
} else {
return -1;
}
}
if (c->begin == c->end) c->begin = c->end = 0;
if (c->read_paused && pending(c) <= LOW_WATER) {
c->read_paused = 0;
printf("fd=%d backlog=%zu, resume read\n", c->fd, pending(c));
}
return update_interest(c);
}
static int queue_bytes(Conn *c, const char *buf, size_t n) {
size_t queued = pending(c);
if (queued + n > HARD_LIMIT) {
printf("fd=%d backlog would exceed hard limit, close\n", c->fd);
return -1;
}
if (c->end + n > OUT_CAP && c->begin > 0) {
memmove(c->out, c->out + c->begin, queued);
c->begin = 0;
c->end = queued;
}
memcpy(c->out + c->end, buf, n);
c->end += n;
if (!c->read_paused && pending(c) >= HIGH_WATER) {
c->read_paused = 1;
printf("fd=%d backlog=%zu, pause read\n", c->fd, pending(c));
}
return 0;
}
static int handle_read(Conn *c) {
char buf[4096];
while (!c->read_paused) {
ssize_t n = recv(c->fd, buf, sizeof(buf), 0);
if (n > 0) {
if (queue_bytes(c, buf, (size_t)n) < 0) return -1;
} else if (n == 0) {
return -1;
} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
break;
} else {
return -1;
}
}
return flush_output(c);
}
int main(void) {
signal(SIGPIPE, SIG_IGN);
int lfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
int one = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_port = htons(PORT),
.sin_addr.s_addr = htonl(INADDR_LOOPBACK)
};
if (bind(lfd, (struct sockaddr *)&addr, sizeof(addr)) < 0 || listen(lfd, 128) < 0) {
perror("listen");
return 1;
}
epfd = epoll_create1(EPOLL_CLOEXEC);
struct epoll_event lev = {.events = EPOLLIN, .data.ptr = &listener_tag};
epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &lev);
printf("listening on 127.0.0.1:%d\n", PORT);
struct epoll_event events[MAX_EVENTS];
for (;;) {
int nready = epoll_wait(epfd, events, MAX_EVENTS, -1);
for (int i = 0; i < nready; i++) {
if (events[i].data.ptr == &listener_tag) {
for (;;) {
int cfd = accept4(lfd, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (cfd < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) break;
perror("accept4");
return 1;
}
Conn *c = calloc(1, sizeof(*c));
c->fd = cfd;
struct epoll_event cev = {
.events = EPOLLIN | EPOLLRDHUP,
.data.ptr = c
};
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &cev);
printf("client fd=%d connected\n", cfd);
}
continue;
}
Conn *c = events[i].data.ptr;
uint32_t e = events[i].events;
int failed = (e & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) != 0;
if (!failed && (e & EPOLLIN)) failed = handle_read(c) < 0;
if (!failed && (e & EPOLLOUT)) failed = flush_output(c) < 0;
if (failed) close_conn(c);
}
}
}预期结果
listening on 127.0.0.1:9090
client fd=<ID> connected
fd=<ID> backlog=32768, pause read
fd=<ID> backlog=8192, resume read<ID> 是运行时分配的文件描述符,实际值会不同。若业务在读取暂停期间仍可能从其他任务产生响应,HARD_LIMIT 会阻止输出队列继续增长;一旦新数据将超过硬上限,连接会被关闭。
选择水位线时看什么
阈值不能只按“单连接能占多少内存”来拍脑袋。高水位至少要容纳正常响应峰值,又必须让总量 单连接上限 × 最大并发连接数 落在进程内存预算内。低水位通常取高水位的较小比例,以减少兴趣集合频繁修改。
背压还必须沿生产链路向上游传播。暂停 EPOLLIN 只能阻止这个客户端继续制造新请求;如果后台任务、消息订阅或广播仍持续给该连接追加响应,就必须让这些生产者也感知队列上限,否则硬上限最终只会把“内存失控”变成“连接被频繁踢掉”。