C / C++ / 系统课时

实现一个可压测的并发 TCP 服务

实现一个可压测的并发 TCP 服务

这节课直接完成一个可运行的 Linux TCP 回显服务:它用长度帧解决粘包拆包,用 epoll 管理并发连接,用高低水位做背压,并通过结构化日志、压力客户端和限时排空验证稳定性与退出行为。

学习目标

  • 实现带 4 字节长度前缀、连接级缓冲区和协议上限的 TCP 服务。
  • 用 epoll 在非阻塞读写中正确处理半包、短写与应用层背压。
  • 通过突发并发压测、日志计数和 SIGTERM 验证吞吐、错误率与优雅退出。

把服务目标收敛成验收约束

本实验把业务处理刻意简化成“收到一帧就原样回一帧”,这样压测结果主要反映网络事件循环和连接状态管理。每帧格式为 4 字节网络字节序长度 + payload,payload 最大 4096 字节;超过上限的连接直接关闭,避免恶意长度导致无限制分配。

一个连接同时维护输入缓冲区、输出缓冲区和 read_paused 状态。输出队列达到 32 KiB 高水位时移除 EPOLLIN,降到 16 KiB 低水位后再恢复读取。这里使用两个水位而不是一个阈值,是为了形成滞回,避免读事件在临界值附近频繁开关。

验收时至少看三件事:压测 errors=0;服务端处理帧数与客户端完成帧数一致;发送 SIGTERM 后不再接收新连接,并在最多 3 秒内尝试发送已经排队的响应。吞吐和尾延迟是环境相关数据,只用于同机基线或改动前后对比。

协议帧、连接状态与背压如何协作

TCP 是字节流,单次 recv 可能只得到半个帧,也可能一次得到多个帧,所以协议解析不能依赖读取次数。服务端先把字节累积到输入缓冲区,只有“4 字节头 + 完整 payload”都到齐后才生成响应;send 写不完时则保留剩余字节,等待下一次 EPOLLOUT。

并发 TCP 服务的数据流与背压状态

这个模型的关键不是 epoll API 本身,而是连接状态必须跨事件保存。如果把输入或输出缓冲区做成一次回调里的局部变量,遇到半包、短写或背压就会丢失上下文。实验还记录 accept、pause-read、resume-read、close 和退出汇总,压测后可以直接核对状态是否真的发生。

实现非阻塞事件循环

下面的 server.c 使用 level-triggered epoll。监听套接字和客户端套接字都设为非阻塞;信号处理器只修改 sig_atomic_t 标志,不在信号上下文里释放内存或关闭整批连接。退出阶段会先关闭监听套接字,再暂停所有连接读取,只排空已经进入输出队列的响应。

c
#define _GNU_SOURCE
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>

#define MAX_EVENTS 128
#define IN_CAP 65536
#define OUT_CAP 65536
#define MAX_FRAME 4096
#define HIGH_WATER 32768
#define LOW_WATER 16384
#define DRAIN_SECONDS 3

enum { ITEM_LISTENER = 1, ITEM_CONN = 2 };

typedef struct {
    int kind;
    int fd;
} Item;

/* 每个连接独立维护输入、输出缓冲区和背压状态。 */
typedef struct Conn {
    Item item;
    unsigned char inbuf[IN_CAP];
    size_t in_len;
    unsigned char outbuf[OUT_CAP];
    size_t out_start;
    size_t out_end;
    int read_paused;
    struct Conn *next;
} Conn;

static volatile sig_atomic_t stopping = 0;
static int draining = 0;
static Conn *connections = NULL;
static uint64_t accepted = 0;
static uint64_t frames = 0;

static void on_signal(int signo) {
    (void)signo;
    stopping = 1;
}

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

static void log_event(const char *event, int fd, size_t queued) {
    fprintf(stderr, "{\"ts\":%ld,\"event\":\"%s\",\"fd\":%d,\"queued\":%zu}\n",
            (long)time(NULL), event, fd, queued);
}

static size_t queued_bytes(const Conn *c) {
    return c->out_end - c->out_start;
}

static uint32_t desired_events(const Conn *c) {
    uint32_t ev = EPOLLRDHUP;
    if (!draining && !c->read_paused) ev |= EPOLLIN;
    if (queued_bytes(c) > 0) ev |= EPOLLOUT;
    return ev;
}

static int update_interest(int epfd, Conn *c) {
    struct epoll_event ev = {0};
    ev.events = desired_events(c);
    ev.data.ptr = c;
    return epoll_ctl(epfd, EPOLL_CTL_MOD, c->item.fd, &ev);
}

static void unlink_conn(Conn *c) {
    Conn **pp = &connections;
    while (*pp && *pp != c) pp = &(*pp)->next;
    if (*pp == c) *pp = c->next;
}

static void close_conn(int epfd, Conn *c) {
    log_event("close", c->item.fd, queued_bytes(c));
    epoll_ctl(epfd, EPOLL_CTL_DEL, c->item.fd, NULL);
    close(c->item.fd);
    unlink_conn(c);
    free(c);
}

static int ensure_output_space(Conn *c, size_t need) {
    if (OUT_CAP - c->out_end >= need) return 0;
    if (c->out_start > 0) {
        memmove(c->outbuf, c->outbuf + c->out_start, queued_bytes(c));
        c->out_end -= c->out_start;
        c->out_start = 0;
    }
    return (OUT_CAP - c->out_end >= need) ? 0 : -1;
}

static int parse_frames(Conn *c) {
    size_t pos = 0;
    while (c->in_len - pos >= 4) {
        /* 帧头是网络字节序的 32 位长度,避免把 TCP 分段误当消息边界。 */
        uint32_t net_len;
        memcpy(&net_len, c->inbuf + pos, sizeof(net_len));
        uint32_t len = ntohl(net_len);
        if (len > MAX_FRAME) return -1;
        size_t frame_size = 4u + (size_t)len;
        if (c->in_len - pos < frame_size) break;
        /* 只有完整帧能进入输出队列;空间不足时暂停继续读取。 */
        if (ensure_output_space(c, frame_size) < 0) {
            if (!c->read_paused) log_event("pause-read", c->item.fd, queued_bytes(c));
            c->read_paused = 1;
            break;
        }
        memcpy(c->outbuf + c->out_end, c->inbuf + pos, frame_size);
        c->out_end += frame_size;
        pos += frame_size;
        frames++;
        if (queued_bytes(c) >= HIGH_WATER) {
            if (!c->read_paused) log_event("pause-read", c->item.fd, queued_bytes(c));
            c->read_paused = 1;
            break;
        }
    }
    if (pos > 0) {
        memmove(c->inbuf, c->inbuf + pos, c->in_len - pos);
        c->in_len -= pos;
    }
    return 0;
}

static int handle_read(int epfd, Conn *c) {
    while (!c->read_paused) {
        if (c->in_len == IN_CAP) {
            if (parse_frames(c) < 0 || c->in_len == IN_CAP) return -1;
            if (c->read_paused) break;
        }
        ssize_t n = recv(c->item.fd, c->inbuf + c->in_len, IN_CAP - c->in_len, 0);
        if (n > 0) {
            c->in_len += (size_t)n;
            if (parse_frames(c) < 0) return -1;
            continue;
        }
        if (n == 0) return -1;
        if (errno == EAGAIN || errno == EWOULDBLOCK) break;
        if (errno == EINTR) continue;
        return -1;
    }
    return update_interest(epfd, c);
}

static int handle_write(int epfd, Conn *c) {
    while (c->out_start < c->out_end) {
        ssize_t n = send(c->item.fd, c->outbuf + c->out_start,
                         c->out_end - c->out_start, MSG_NOSIGNAL);
        if (n > 0) {
            c->out_start += (size_t)n;
            continue;
        }
        if (n < 0 && errno == EINTR) continue;
        /* 非阻塞套接字返回 EAGAIN 代表本轮已写到内核发送缓冲区上限。 */
        if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) break;
        return -1;
    }
    if (c->out_start == c->out_end) c->out_start = c->out_end = 0;
    /* 低水位恢复 EPOLLIN,形成高低水位滞回,避免频繁开关读取。 */
    if (!draining && c->read_paused && queued_bytes(c) <= LOW_WATER) {
        c->read_paused = 0;
        log_event("resume-read", c->item.fd, queued_bytes(c));
        if (parse_frames(c) < 0) return -1;
    }
    return update_interest(epfd, c);
}

static int accept_clients(int epfd, int listen_fd) {
    for (;;) {
        /* 新连接从创建起就是非阻塞并带 CLOEXEC,避免后续再改状态的竞态。 */
        int fd = accept4(listen_fd, NULL, NULL, SOCK_NONBLOCK | SOCK_CLOEXEC);
        if (fd < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) return 0;
            if (errno == EINTR) continue;
            return -1;
        }
        Conn *c = calloc(1, sizeof(*c));
        if (!c) {
            close(fd);
            return -1;
        }
        c->item.kind = ITEM_CONN;
        c->item.fd = fd;
        c->next = connections;
        connections = c;

        struct epoll_event ev = {0};
        ev.events = EPOLLIN | EPOLLRDHUP;
        ev.data.ptr = c;
        if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) < 0) {
            close_conn(epfd, c);
            return -1;
        }
        accepted++;
        log_event("accept", fd, 0);
    }
}

static void drain_and_close(int epfd) {
    draining = 1;
    time_t deadline = time(NULL) + DRAIN_SECONDS;
    struct epoll_event events[MAX_EVENTS];

    /* 退出阶段不再读新请求,只给已排队响应一个有限的排空窗口。 */
    for (Conn *c = connections; c; c = c->next) {
        c->read_paused = 1;
        update_interest(epfd, c);
    }

    while (connections && time(NULL) < deadline) {
        int n = epoll_wait(epfd, events, MAX_EVENTS, 100);
        if (n < 0) {
            if (errno == EINTR) continue;
            break;
        }
        for (int i = 0; i < n; i++) {
            Item *item = events[i].data.ptr;
            if (!item || item->kind != ITEM_CONN) continue;
            Conn *c = (Conn *)item;
            if ((events[i].events & EPOLLOUT) && handle_write(epfd, c) < 0) {
                close_conn(epfd, c);
                continue;
            }
            if (events[i].events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
                close_conn(epfd, c);
            }
        }
        Conn *c = connections;
        while (c) {
            Conn *next = c->next;
            if (queued_bytes(c) == 0) close_conn(epfd, c);
            c = next;
        }
    }

    while (connections) close_conn(epfd, connections);
}

int main(int argc, char **argv) {
    int port = (argc == 2) ? atoi(argv[1]) : 9000;
    if (port <= 0 || port > 65535) {
        fprintf(stderr, "usage: %s [port]\n", argv[0]);
        return 2;
    }

    /* 信号处理器只置位,真正的资源回收留在事件循环线程执行。 */
    struct sigaction sa = {0};
    sa.sa_handler = on_signal;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
    signal(SIGPIPE, SIG_IGN);

    int listen_fd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
    if (listen_fd < 0) { perror("socket"); return 1; }
    int one = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    if (set_nonblock(listen_fd) < 0) { perror("fcntl"); return 1; }

    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons((uint16_t)port);
    if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind"); return 1;
    }
    if (listen(listen_fd, SOMAXCONN) < 0) { perror("listen"); return 1; }

    int epfd = epoll_create1(EPOLL_CLOEXEC);
    if (epfd < 0) { perror("epoll_create1"); return 1; }
    Item listener = {.kind = ITEM_LISTENER, .fd = listen_fd};
    struct epoll_event lev = {.events = EPOLLIN, .data.ptr = &listener};
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &lev) < 0) {
        perror("epoll_ctl"); return 1;
    }

    fprintf(stderr, "listening on 0.0.0.0:%d\n", port);
    struct epoll_event events[MAX_EVENTS];

    /* 单线程 epoll 同时推进多个连接的读写状态,不为每个连接创建线程。 */
    while (!stopping) {
        int n = epoll_wait(epfd, events, MAX_EVENTS, -1);
        if (n < 0) {
            if (errno == EINTR) continue;
            perror("epoll_wait"); break;
        }
        for (int i = 0; i < n; i++) {
            Item *item = events[i].data.ptr;
            if (item->kind == ITEM_LISTENER) {
                if (accept_clients(epfd, listen_fd) < 0) perror("accept4");
                continue;
            }
            Conn *c = (Conn *)item;
            uint32_t ev = events[i].events;
            if ((ev & EPOLLIN) && handle_read(epfd, c) < 0) {
                close_conn(epfd, c);
                continue;
            }
            if ((ev & EPOLLOUT) && handle_write(epfd, c) < 0) {
                close_conn(epfd, c);
                continue;
            }
            if (ev & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
                close_conn(epfd, c);
            }
        }
    }

    epoll_ctl(epfd, EPOLL_CTL_DEL, listen_fd, NULL);
    close(listen_fd);
    fprintf(stderr, "stopping: accepted=%llu frames=%llu\n",
            (unsigned long long)accepted, (unsigned long long)frames);
    drain_and_close(epfd);
    close(epfd);
    return 0;
}

预期结果:将代码保存为 server.c 后,可以只依赖 glibc 和 Linux 系统调用完成编译;协议长度大于 4096 字节的连接会被关闭,正常完整帧会被原样回显。

编译并启动服务:

bash
gcc -std=c11 -O2 -Wall -Wextra -Wpedantic server.c -o framed-server
./framed-server 9000 2>server.log &
SERVER_PID=$!
printf 'server pid=%s\n' "$SERVER_PID"

预期输出:

text
server pid=<PID>

<PID> 会随每次运行变化。若 gcc 有编译错误,先修正后再继续;若启动后 server.log 出现 bind: Address already in use,说明 9000 端口已被占用,需要结束占用进程或改用其他端口。

用突发并发压测验证稳定性

普通“一发一收”客户端很难把服务端输出队列推到高水位,因此压测客户端按批次连续发送多个帧,再逐个读取响应。这样既制造多连接并发,也能验证服务端在一轮 EPOLLIN 中积累输出后是否真正暂停和恢复读取。

python
import socket
import struct
import sys
import threading
import time

def recv_exact(sock, size):
    # TCP 只保证字节流顺序,必须循环读取到协议需要的精确长度。
    chunks = []
    left = size
    while left:
        chunk = sock.recv(left)
        if not chunk:
            raise ConnectionError("peer closed")
        chunks.append(chunk)
        left -= len(chunk)
    return b"".join(chunks)

def worker(host, port, batches, pipeline, payload_size, latencies, completed, lock):
    payload = b"x" * payload_size
    # 一次突发发送多个长度帧,既制造并发,也能逼近服务端输出高水位。
    frame = struct.pack("!I", len(payload)) + payload
    local_latency = []
    local_completed = 0
    try:
        with socket.create_connection((host, port), timeout=5) as sock:
            # 每个线程复用一条长连接,避免把建连成本重复计入每个帧。
            for _ in range(batches):
                start = time.perf_counter_ns()
                sock.sendall(frame * pipeline)
                for _ in range(pipeline):
                    length = struct.unpack("!I", recv_exact(sock, 4))[0]
                    echoed = recv_exact(sock, length)
                    if echoed != payload:
                        raise ValueError("payload mismatch")
                    local_completed += 1
                local_latency.append((time.perf_counter_ns() - start) / 1_000_000)
    except Exception:
        pass
    with lock:
        latencies.extend(local_latency)
        completed[0] += local_completed

def percentile(values, p):
    # 这里统计的是一批 pipeline 帧全部往返完成的延迟。
    if not values:
        return float("nan")
    values = sorted(values)
    index = min(len(values) - 1, int((len(values) - 1) * p))
    return values[index]

def main():
    if len(sys.argv) != 7:
        raise SystemExit(
            "usage: load_client.py HOST PORT CLIENTS BATCHES PIPELINE PAYLOAD_BYTES"
        )
    host, port_s, clients_s, batches_s, pipeline_s, payload_s = sys.argv[1:]
    port = int(port_s)
    clients = int(clients_s)
    batches = int(batches_s)
    pipeline = int(pipeline_s)
    payload_size = int(payload_s)
    latencies = []
    completed = [0]
    lock = threading.Lock()
    # 标准库线程足以制造并发 socket I/O,无需安装第三方压测包。
    threads = [
        threading.Thread(
            target=worker,
            args=(host, port, batches, pipeline, payload_size, latencies, completed, lock),
        )
        for _ in range(clients)
    ]
    start = time.perf_counter()
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
    elapsed = time.perf_counter() - start
    total = clients * batches * pipeline
    errors = total - completed[0]
    print(
        f"frames={total} completed={completed[0]} errors={errors} "
        f"duration={elapsed:.3f}s fps={completed[0] / elapsed:.1f}"
    )
    print(
        "batch_latency_ms "
        f"p50={percentile(latencies, 0.50):.3f} "
        f"p95={percentile(latencies, 0.95):.3f} "
        f"p99={percentile(latencies, 0.99):.3f}"
    )

if __name__ == "__main__":
    main()

预期结果:将脚本保存为 load_client.py 后无需第三方依赖;它会校验每个回显 payload,并统计完成帧数、错误数、帧吞吐以及每批 pipeline 帧的延迟分位点。

运行 20 条长连接,每条连接执行 20 个批次,每批突发 64 帧,每帧 512 字节:

bash
python3 load_client.py 127.0.0.1 9000 20 20 64 512

预期输出:

text
frames=25600 completed=25600 errors=0 duration=<TIME>s fps=<VALUE>
batch_latency_ms p50=<VALUE> p95=<VALUE> p99=<VALUE>

<TIME> 和 <VALUE> 取决于 CPU、内核、虚拟化和当前负载,不能拿不同机器的绝对值直接比较。这里最先检查的是 completed=25600 与 errors=0;batch_latency_ms 表示一批 64 帧全部往返完成的时间,不是单帧延迟。

核对背压、日志与优雅退出

先确认压测期间高低水位确实被触发。由于内核每次交付给用户态的字节数不同,暂停和恢复次数不是固定值,但在上述突发参数下通常都应大于 0。

bash
printf 'pause=%s resume=%s\n' \
  "$(grep -c 'pause-read' server.log)" \
  "$(grep -c 'resume-read' server.log)"

预期输出:

text
pause=<VALUE> resume=<VALUE>

若两个值长期都是 0,可以增大 PIPELINE 或 payload,让单连接在一次突发中产生更多待发送数据;不要通过无限增大固定缓冲区来“解决”背压,那只会把失控点推迟到更高内存占用。

压测完成后向服务发送 SIGTERM 并等待它退出,再核对汇总计数:

bash
kill -TERM "$SERVER_PID"
wait "$SERVER_PID"
grep 'stopping:' server.log | tail -n 1

预期输出:

text
stopping: accepted=20 frames=25600

这个结果成立的前提是前面的压测 errors=0 且没有额外客户端连接。服务收到终止信号后会停止 accept,只给已有输出最多 3 秒的排空窗口,然后关闭剩余连接;因此它不会无限等待慢客户端。

当错误率为 0、服务端帧计数与客户端完成数一致、背压日志可观察,并且 SIGTERM 能在有限时间内结束进程时,这个服务才算形成了“协议正确、连接状态可控、慢端不会无限拖垮、退出可预期”的最小工程闭环。

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

目录与阅读设置

阅读设置

17

记录一个想法

实现一个可压测的并发 TCP 服务

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

登录哪都通