极客教程

Appearance

Day 3: 短连接 vs 长连接 — 消除 close() 后的性能跃迁 ​

所属阶段：阶段 1 — 从零写出 Echo 服务 前置依赖：Day 2 — epoll/多进程/短连接压测基线 更新时间：2026-08-20（重构：按"一篇实验 = 一个知识点"拆分为 5 篇小实验；原单篇 39KB 文档拆分后各实验独立成文） 阶段小结：Day 0-3 小结

一、本 Day 在做什么 ​

Day 2 通过 strace -c 发现：短连接模式下，close() 占服务端总系统调用时间的 21-28%（单次 close 耗时 35-58μs）。Day 3 用同一把尺子量短连接和长连接，验证一个预测：

改用长连接（connect 一次、多轮 echo、再 close），消除单次请求的 connect/close 开销，QPS 应有 2-5× 的提升。

Day 3 做的事很简单：服务端本来就是长连接兼容的（Day 2 的状态机天然支持 STATE_WRITE → STATE_READ 回路，服务端从不主动关连接），客户端改一下策略——原来每轮 connect → send → recv → close，现在改成 connect → (send → recv) × R → close。不需要协议扩展、不需要 HTTP 头、不需要内核参数，纯粹是应用层连接管理策略的改变。

二、名词澄清："Keep-Alive"指什么 ​

Day 3 语境下的"Keep-Alive"是应用层长连接——客户端和服务端约定"TCP 连接建好后不关闭，复用同一条连接发多轮请求"。它不是以下任何一种：

不是区别
HTTP Connection: keep-aliveHTTP/1.1 默认行为，告诉对端"发完这个响应别关连接"。底层机制相同（复用 TCP 连接），但 Day 3 不涉及 HTTP 协议
TCP SO_KEEPALIVE内核级 TCP 保活探测——连接空闲太久时发探测包确认对端还活着。与"复用连接发多轮请求"是两回事
HTTP/2 多路复用在一条 TCP 连接上并发多个请求/响应流。Day 3 只是单线程串行复用，不涉及多路复用

所以 Day 3 的"Keep-Alive"其实就是"应用层长连接"——借用了 HTTP 的习惯叫法，但实现上更原始、更可控：没有协议头协商、没有超时规则、没有管线化，就是 TCP 连接不关而已。

三、本 Day 的 4 个问题 → 5 篇小实验 ​

#问题实验核心发现
Q1长连接 QPS 实际提升多少倍？实验 3.1 长连接 QPS 对比ET 2.15×（LT 仅 1.48×，被重复通知拖累）
Q2LT vs ET 差距是否终于显现？实验 3.2 LT vs ETET 高 37.2%，远超 5-10% 预期
Q3并发连接数如何衰减、拐点在哪？实验 3.3 连接数扫描500 连接拐点，之后单线程天花板平台期
机制close() 真的被消除了吗？实验 3.4 strace 实证close/connect 次数 -90%、耗时 -87%
Q4跨网络延迟来自哪些层？实验 3.5 跨网络部署增量 ≈ 1-2 个网络 RTT（9.1ms）

阅读顺序：3.1 → 3.4（Q1 及机制）→ 3.2（Q2）→ 3.3（Q3）→ 3.5（Q4，可选）。

四、核心结论速览（Q&A 一行版） ​

问题答案
Q1ET 24915→53528（2.15×）；LT 26433→39010（1.48×）。与 Day 2 预测 2-5× 基本一致
Q2显现且超预期：长连接下 ET 比 LT 高 37.2%；差距全在 LT 的重复通知（P99 7481 vs 1894μs）
Q3拐点 500 连接（100→500 掉 88%），之后 2700-3900 平台期；5000 短连接崩盘（QPS 387 + fail 248），长连接 3222 零失败
Q4P50 增约 4 倍（长 3336→14442μs）；min 增量精确等于 1×RTT（长）/ 2×RTT（短），RTT=9.1ms
机制close/connect 次数 -90%、syscall 总耗时 -86.7%（3.23s→0.43s）

五、与 Day 2 的关键差异 ​

维度Day 2（短连接）Day 3（长连接）
连接模型每次请求：connect → send → recv → closeconnect → N×(send → recv) → close
主要瓶颈close() syscall（21-28%）LT 的 epoll 重复通知（ET 高 37.2%）
LT vs ET几乎无差异ET 优势显现且超预期（37.2%）
压测工具echo-bench.c（串行）echo-kp-bench.c（并行，pthread_barrier 同步）
最可复现的科学问题"为什么 close() 这么贵？""消除 close() 到底值多少 QPS？"（ET 2.15×）

六、衔接后续 ​

Day 3 把连接层瓶颈清空后，露出了下一层瓶颈：

Day 3 暴露的瓶颈证据后续迭代方向对应阶段
单线程 epoll 天花板500 连接后 QPS 悬崖（掉 88%），5000 长连接仅 3222
c
/*
 * echo-mp-server.c — 多进程 + SO_REUSEPORT + 每进程独立 epoll
 *
 * 每个 worker 进程独立完成 socket/bind/listen/epoll，
 * 利用 SO_REUSEPORT 让内核把新连接**均匀分发**到各进程的 listen 队列。
 *
 * 设计意图：
 *   1. 隔离性：一个进程崩溃不影响其他进程
 *   2. 缓存亲和：每个进程粘在一组 CPU 核上，L1/L2 缓存命中率高
 *   3. 为后续 NUMA 拆分（day-06）埋基础
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT           9988
#define MAX_EVENTS     1024
#define BUFFER_SIZE    4096
#define LISTEN_BACKLOG 128
#define NUM_WORKERS    4         /* 默认 worker 进程数 */

/* ---------- 工具函数 ---------- */

static void set_nonblocking(int fd)
{
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0) { perror("fcntl F_GETFL"); exit(1); }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
        perror("fcntl O_NONBLOCK"); exit(1);
    }
}

/* ---------- 每个连接的状态 ---------- */

enum conn_state {
    STATE_READ,
    STATE_WRITE,
    STATE_CLOSE,
};

struct connection {
    int             fd;
    enum conn_state state;
    char            buf[BUFFER_SIZE];
    ssize_t         buf_len;
    ssize_t         buf_sent;
};

/* ---------- worker 进程的主循环 ---------- */

static void worker_loop(int worker_id)
{
    int listen_fd, epoll_fd;
    struct sockaddr_in addr;
    struct epoll_event ev, events[MAX_EVENTS];

    struct connection *conns = calloc(65536, sizeof(struct connection));
    if (!conns) { perror("calloc"); exit(1); }

    /* 1. socket + SO_REUSEPORT */
    listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd < 0) { perror("socket"); exit(1); }

    int optval = 1;
    if (setsockopt(listen_fd, SOL_SOCKET, SO_REUSEPORT,
                   &optval, sizeof(optval)) < 0) {
        perror("setsockopt SO_REUSEPORT"); exit(1);
    }
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

    set_nonblocking(listen_fd);

    /* 2. bind */
    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port        = htons(PORT);

    if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind"); exit(1);
    }

    /* 3. listen */
    if (listen(listen_fd, LISTEN_BACKLOG) < 0) {
        perror("listen"); exit(1);
    }

    /* 4. epoll */
    epoll_fd = epoll_create1(0);
    if (epoll_fd < 0) { perror("epoll_create1"); exit(1); }

    ev.events  = EPOLLIN | EPOLLET;
    ev.data.fd = listen_fd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_fd, &ev);

    printf("[worker %d] pid=%d, listening on port %d\n",
           worker_id, getpid(), PORT);

    /* 5. 事件循环（与 echo-epoll-server 一致） */
    while (1) {
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (nfds < 0) {
            if (errno == EINTR) continue;
            perror("epoll_wait"); break;
        }

        for (int i = 0; i < nfds; i++) {
            if (events[i].data.fd == listen_fd) {
                /* accept 循环（边缘触发必须循环到 EAGAIN） */
                while (1) {
                    int fd = accept(listen_fd, NULL, NULL);
                    if (fd < 0) {
                        if (errno == EAGAIN || errno == EWOULDBLOCK) break;
                        perror("accept"); break;
                    }

                    set_nonblocking(fd);
                    struct connection *c = &conns[fd];
                    c->fd       = fd;
                    c->state    = STATE_READ;
                    c->buf_len  = 0;
                    c->buf_sent = 0;

                    struct epoll_event cev;
                    cev.events   = EPOLLIN | EPOLLET;
                    cev.data.ptr = c;
                    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &cev);
                }
            } else {
                struct connection *c = (struct connection *)events[i].data.ptr;

                if (events[i].events & (EPOLLERR | EPOLLHUP)) {
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, c->fd, NULL);
                    close(c->fd);
                    memset(c, 0, sizeof(*c));
                    continue;
                }

                /* 状态机：READ → WRITE → READ */
                if (c->state == STATE_READ && (events[i].events & EPOLLIN)) {
                    /* 循环读到 EAGAIN */
                    while (1) {
                        if (c->buf_len >= (ssize_t)sizeof(c->buf)) break;
                        ssize_t n = read(c->fd,
                                         c->buf + c->buf_len,
                                         sizeof(c->buf) - c->buf_len);
                        if (n > 0) { c->buf_len += n; continue; }
                        if (n == 0) { c->state = STATE_CLOSE; break; }
                        if (errno == EAGAIN || errno == EWOULDBLOCK) break;
                        perror("read"); c->state = STATE_CLOSE; break;
                    }

                    if (c->buf_len > 0 && c->state != STATE_CLOSE) {
                        c->buf_sent = 0;
                        c->state = STATE_WRITE;
                        struct epoll_event wev;
                        wev.events   = EPOLLOUT | EPOLLET;
                        wev.data.ptr = c;
                        epoll_ctl(epoll_fd, EPOLL_CTL_MOD, c->fd, &wev);
                    }
                }
                else if (c->state == STATE_WRITE && (events[i].events & EPOLLOUT)) {
                    while (c->buf_sent < c->buf_len) {
                        ssize_t n = write(c->fd,
                                          c->buf + c->buf_sent,
                                          c->buf_len - c->buf_sent);
                        if (n > 0) { c->buf_sent += n; continue; }
                        if (errno == EAGAIN || errno == EWOULDBLOCK) break;
                        perror("write"); c->state = STATE_CLOSE; break;
                    }

                    if (c->buf_sent >= c->buf_len) {
                        /* 写完，切回读 */
                        c->buf_len  = 0;
                        c->buf_sent = 0;
                        c->state    = STATE_READ;
                        struct epoll_event rev;
                        rev.events   = EPOLLIN | EPOLLET;
                        rev.data.ptr = c;
                        epoll_ctl(epoll_fd, EPOLL_CTL_MOD, c->fd, &rev);
                    }
                }

                if (c->state == STATE_CLOSE) {
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, c->fd, NULL);
                    close(c->fd);
                    memset(c, 0, sizeof(*c));
                }
            }
        }
    }

    close(epoll_fd);
    close(listen_fd);
    free(conns);
}

/* ---------- 主进程：fork workers + 收割僵尸 ---------- */

static volatile sig_atomic_t running = 1;

static void sig_handler(int sig)
{
    (void)sig;
    running = 0;
}

int main(int argc, char *argv[])
{
    int num_workers = NUM_WORKERS;
    if (argc > 1) num_workers = atoi(argv[1]);
    if (num_workers < 1) num_workers = 1;

    /* 信号处理：优雅退出 */
    signal(SIGINT,  sig_handler);
    signal(SIGTERM, sig_handler);
    signal(SIGCHLD, SIG_DFL);   /* 子进程退出用 waitpid 收割 */

    printf("Master pid=%d, starting %d workers ...\n", getpid(), num_workers);

    pid_t *children = calloc(num_workers, sizeof(pid_t));

    for (int i = 0; i < num_workers; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork"); exit(1);
        }

        if (pid == 0) {
            /* 子进程：进入事件循环 */
            free(children);
            worker_loop(i);
            exit(0);
        }

        children[i] = pid;
    }

    printf("Master: all %d workers started, waiting ...\n", num_workers);

    /* 主进程：等子进程退出，收割僵尸 */
    while (running) {
        int status;
        pid_t pid = waitpid(-1, &status, WNOHANG);
        if (pid > 0) {
            printf("Master: worker pid=%d exited (status=%d)\n",
                   pid, WEXITSTATUS(status));
            /* 生产环境应该在这里重新 fork 一个 */
        }
        sleep(1);
    }

    /* 退出时杀掉所有子进程 */
    printf("Master: shutting down workers ...\n");
    for (int i = 0; i < num_workers; i++) {
        if (children[i] > 0) kill(children[i], SIGTERM);
    }
    /* 等子进程全部退出 */
    for (int i = 0; i < num_workers; i++) {
        if (children[i] > 0) waitpid(children[i], NULL, 0);
    }

    free(children);
    printf("Master: all workers stopped.\n");
    return 0;
}
阶段 2（Day 4-6）
LT 重复通知长连接 ET 高 37.2%已换 ET；进一步 EPOLLONESHOT / 忙轮询 / 批量 readv-writev阶段 4
5000 短连接崩盘QPS 387 + fail 248TIME_WAIT 与端口耗尽治理（tcp_tw_reuse / fin_timeout / ip_local_port_range）阶段 3 + 7
跨网络延迟硬下限P50 ≈ 1-2 个网络 RTT网络层非本地可优化，改走长连接 + 多连接复用阶段 6（百万长连接）

一句话总结：Day 3 的终点是 Day 4 的起点——"消除 close() 换来的吞吐优势，必须靠多核并行（多线程 + RSS 多队列 + IRQ 亲和）才能兑现"。

附录：操作清单 ​

跑实验前的必备检查 ​

bash
# 1. 确认 ulimit（< 10000 时执行 ulimit -n 65535）
ulimit -n
# 2. 确认 sysctl
sysctl net.ipv4.tcp_tw_reuse
sysctl net.ipv4.tcp_fin_timeout
sysctl net.ipv4.ip_local_port_range
# 3. 确认端口未被占用
ss -tlnp | grep 9988
# 4. 编译
cd demos/echo/day-03 && make all

快速跑全部实验 ​

bash
# 终端 1：启动 LT 服务端
make run-lt
# 终端 2：一键全跑（3.1~3.4）
make run-all

本次实验命令记录（2026-08-12） ​

结果文件均留档于服务器 /root/echo-day03/。

0. 环境准备（腾讯云 4 核 CentOS 7，公网 124.221.142.185）

bash
cd /root/echo-day03 && make all
# TIME-WAIT 不成为瓶颈 + 本地端口范围足够大
sysctl -w net.ipv4.tcp_tw_reuse=1
sysctl -w net.ipv4.tcp_fin_timeout=5
sysctl -w net.ipv4.ip_local_port_range="32768 60999"
ulimit -n 65535
nohup ./echo-epoll-lt-server > lt34.log 2>&1 &    # LT 版
nohup ./echo-epoll-server  > et34.log 2>&1 &      # ET 版

1. 实验 3.1：LT/ET × 短/长连接，各 3 轮（结果 → results31/）

bash
for m in short long; do
  for i in 1 2 3; do
    ./echo-kp-bench 127.0.0.1 9988 100 10 --mode $m > results31/lt-$m-r$i.txt
  done
done
# 停 LT、启 ET 后重复，结果 → results31/et-$m-r$i.txt

2. 实验 3.2：连接数扫描 100→5000（结果 → results32/ 首测、results32b/ 复测）

bash
for c in 100 500 1000 2000 5000; do
  ./echo-kp-bench 127.0.0.1 9988 $c 10 --mode short > results32b/scan-$c-short.txt
  ./echo-kp-bench 127.0.0.1 9988 $c 10 --mode long  > results32b/scan-$c-long.txt
done

3. 实验 3.3：strace 对比 close/connect（结果 → s33-short.sum / s33-long.sum）

bash
strace -f -c -e trace=connect,close \
  ./echo-kp-bench 127.0.0.1 9988 100 10 --mode short 2> s33-short.sum
strace -f -c -e trace=connect,close \
  ./echo-kp-bench 127.0.0.1 9988 100 10 --mode long  2> s33-long.sum

4. 实验 3.5：跨网络部署对比（Python 客户端，同一把尺子）

bash
# ① 服务器内 localhost 基线（结果 → results34/lo-*.txt）
for m in short long; do
  for i in 1 2 3; do
    PYTHONIOENCODING=utf-8 python3 bench_py.py 127.0.0.1 9988 100 10 --mode $m \
      > results34/lo-$m-r$i.txt
  done
done
# ② 本地 macOS 远程压测（结果 → results34/rm-*.txt，已回传服务器留档）
for m in short long; do
  for i in 1 2 3; do
    PYTHONIOENCODING=utf-8 python3 bench_py.py 124.221.142.185 9988 100 10 --mode $m \
      > results34/rm-$m-r$i.txt
  done
done
# ③ 前置：公网端口放行（安全组 + firewalld 9988/tcp）
firewall-cmd --permanent --add-port=9988/tcp && firewall-cmd --reload