操作系统 / 系统课时

用背压限制慢客户端占用

用背压限制慢客户端占用

事件驱动服务器最危险的慢连接,不是“收不到数据”,而是应用持续产生响应、内核却迟迟发不出去。本篇用高低水位线限制单连接待发送数据:积压过高时暂停读取,回落后恢复;超过硬上限则主动断开,从而把内存和事件循环开销控制在可预期范围内。

学习目标

  • 识别发送速度低于业务产出速度时,用户态输出队列为何会持续增长。
  • 用高水位、低水位和硬上限设计稳定的背压策略。
  • 在 epoll 中动态关闭和恢复 EPOLLIN,避免慢客户端拖累其他连接。

慢客户端为什么会放大资源占用

非阻塞 send() 返回 EAGAIN 时,说明当前不能继续写入套接字发送缓冲区。此时应用只能把尚未发送的数据留在用户态队列中。如果业务仍继续读取请求并生成响应,队列就会越积越多,单个客户端最终可能占用大量内存,并反复触发可写事件处理。

背压的关键不是“让网络变快”,而是在输出积压达到阈值后停止继续制造更多输出。最常用的做法是给每个连接维护待发送字节数,并用三个阈值约束它。

慢客户端背压状态与水位线

用高低水位线避免频繁抖动

只设一个阈值会导致队列在阈值附近反复暂停和恢复读取。高低水位形成“滞回区间”:达到高水位才暂停,必须下降到更低的低水位才恢复。

阈值 本例取值 动作
低水位 8 KiB 已暂停且积压降到此值以下时恢复读取
高水位 32 KiB 暂停该连接的读取事件
硬上限 60 KiB 拒绝继续排队并关闭连接

高水位应明显低于硬上限,给已经在处理中的响应和协议开销留出余量。硬上限不是流量调节器,而是最后一道资源保护线。

把背压接入 epoll

下面是一个最小可运行的非阻塞 echo 服务器。每个连接有固定输出缓冲区;当积压达到高水位时,从兴趣集合中移除 EPOLLIN,只有待发送数据降到低水位后才恢复读取。

c
#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);
        }
    }
}

预期结果

text
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 只能阻止这个客户端继续制造新请求;如果后台任务、消息订阅或广播仍持续给该连接追加响应,就必须让这些生产者也感知队列上限,否则硬上限最终只会把“内存失控”变成“连接被频繁踢掉”。

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

目录与阅读设置

阅读设置

17

记录一个想法

用背压限制慢客户端占用

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

登录哪都通