第5周：TCP 协议栈内部机制

字数统计: 1.9k字   |   阅读时长≈ 9分

第5周：TCP 协议栈内部机制

目标：深入理解 TCP 协议栈细节，掌握关键 socket 选项的使用场景。

1. TCP 协议栈核心机制

1.1 Nagle 算法

问题：小包发送效率低（每个包 40 字节头 + 少量数据）

1
2
3
4
5
6
发送端发送 "H" (1 byte)
  → 立即发送 TCP 包（1 字节数据 + 40 字节头 = 41 字节）

发送端发送 "e" (1 byte)
  → 等待 ACK 或积累到 MSS 才发送
  → 如果 ACK 到了，发送累积的数据

Nagle 算法规则：

1
2
3
4
5
6
7
8
if (有未确认的数据 AND 数据 < MSS) {
    缓存新数据，等待：
      a) 累积到 MSS
      b) 收到之前数据的 ACK
      c) 没有更多数据要发
} else {
    立即发送
}

关闭 Nagle：

1
2
int flag = 1;
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));

使用场景：

  • 交互式应用（SSH、telnet、游戏）：关闭 Nagle，降低延迟
  • 文件传输、批量数据：保持 Nagle，提高吞吐

1.2 延迟确认（Delayed ACK）

1
2
3
4
5
接收方收到数据后：
  - 不立即发 ACK
  - 等待最多 200ms（Linux 默认 ~40ms）
  - 如果这期间有数据要发，捎带 ACK
  - 如果收到连续两个包，立即 ACK（每两个包一个 ACK）

影响 Nagle + Delayed ACK 的经典问题：

1
2
3
4
5
6
7
8
9
10
11
12
发送方（Nagle 开启）：
  1. 发送 1 字节 → 等待 ACK

接收方（Delayed ACK）：
  - 收到 1 字节
  - 不立即 ACK（等 40ms）
  - 也没有数据回发

结果：发送方等 40ms 才收到 ACK，然后发送下一个数据
= 每个小包增加 40ms 延迟！

解决：关闭发送方 Nagle（TCP_NODELAY）或接收方 Delayed ACK（TCP_QUICKACK）
1
2
3
4
5
6
// 关闭延迟 ACK
int flag = 1;
setsockopt(fd, IPPROTO_TCP, TCP_QUICKACK, &flag, sizeof(flag));

// 注意：TCP_QUICKACK 是"一次性"设置
// 每次收到数据后可能需要重新设置（取决于内核行为）

1.3 Keepalive

1
2
3
4
5
6
7
8
9
10
11
int keepalive = 1;
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive));

// 自定义参数（Linux 2.6+）
int idle = 60;       // 空闲 60 秒后开始探测
int interval = 10;   // 每 10 秒探测一次
int count = 3;       // 探测 3 次失败后断开

setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &interval, sizeof(interval));
setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &count, sizeof(count));

2. 关键 Socket 选项

2.1 SO_REUSEADDR

1
2
int opt = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

作用：

  • 允许在 TIME_WAIT 状态下重新绑定同一端口
  • 解决”Address already in use”问题
  • 多进程绑定同一端口进行负载均衡（配合 SO_REUSEPORT）

注意：

  • 必须设置在 bind() 之前
  • 不影响正在使用中的连接

2.2 SO_REUSEPORT

1
2
int opt = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

作用：

  • 允许多个 socket（可跨进程）绑定同一 (IP, Port)
  • 内核自动负载均衡分发新连接到不同 socket
  • 实现内核级别的 accept 负载均衡

对比：

特性 SO_REUSEADDR SO_REUSEPORT
多进程 bind 部分支持 完全支持
负载均衡 无 内核级
惊群 仍有 消除
Linux 版本 3.9+ 3.9+

2.3 TCP 缓冲区调优

1
2
3
4
5
6
7
8
9
10
11
12
// 发送缓冲区
int sndbuf = 256 * 1024;  // 256KB
setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));

// 接收缓冲区
int rcvbuf = 256 * 1024;
setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));

// 自动调优（Linux 3.6+，推荐）
int autotune = 1;
setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &autotune, sizeof(autotune));
setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &autotune, sizeof(autotune));

2.4 SO_LINGER

1
2
3
4
5
struct linger ling = {
    .l_onoff = 1,     // 启用 linger
    .l_linger = 0     // 0 = 强制关闭（RST）
};
setsockopt(fd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));

行为对比：

l_onoff l_linger close() 行为
0 - 默认（优雅关闭，等待数据发送完）
1 0 立即发 RST，丢弃缓冲区数据
1 >0 等待最多 l_linger 秒发送剩余数据

2.5 选项速查表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Socket 层选项
SO_REUSEADDR      // 地址复用
SO_REUSEPORT      // 端口复用
SO_KEEPALIVE      // TCP keepalive
SO_LINGER         // close 行为
SO_SNDBUF/SO_RCVBUF // 缓冲区大小
SO_BROADCAST      // 允许广播（UDP）
SO_RCVTIMEO/SO_SNDTIMEO  // 收发超时

// TCP 层选项
TCP_NODELAY       // 关闭 Nagle
TCP_QUICKACK      // 关闭延迟 ACK
TCP_CORK          // 暂不发送（凑满 MSS）
TCP_KEEPIDLE      // keepalive 开始时间
TCP_KEEPINTVL     // keepalive 间隔
TCP_KEEPCNT       // keepalive 探测次数
TCP_DEFER_ACCEPT  // 延迟接受（直到有数据）
TCP_FASTOPEN      // TCP Fast Open（TFO）
TCP_INFO          // 获取 TCP 信息

3. TCP 超时与重传

3.1 RTO（Retransmission Timeout）

1
2
3
4
5
6
7
8
RTT (Round Trip Time) = 往返时间
RTO = SRTT + 4 × RTTVAR

SRTT (Smoothed RTT) = (1 - α) × SRTT + α × RTT
    α = 1/8 = 0.125

RTTVAR = (1 - β) × RTTVAR + β × |SRTT - RTT|
    β = 1/4 = 0.25

3.2 Linux TCP 超时参数

1
2
3
4
5
6
7
8
9
10
# 查看 / 设置
sysctl net.ipv4.tcp_syn_retries        # SYN 重试次数（默认 6）
sysctl net.ipv4.tcp_synack_retries     # SYN+ACK 重试次数（默认 5）
sysctl net.ipv4.tcp_retries1           # 数据段重试次数（默认 3）
sysctl net.ipv4.tcp_retries2           # 数据段最大重试（默认 15）
sysctl net.ipv4.tcp_orphan_retries     # orphan socket 重试（默认 7）

# 实际超时时间
# SYN:    1s, 2s, 4s, 8s, 16s, 32s → 约 127 秒
# 数据：   3s, 6s, 12s, 24s, 48s, 90s, ... → 约 13-30 分钟
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 查看当前 TCP 连接的超时和重传状态
ss -ti  # 显示 TCP 信息（RTO, RTT, CWND 等）

# 输出示例
#  sk mem:(r0,rb87376,t0,tb0,f0,w0,o0,bl0)
#  skb->tcp_ts_recent = 0
#  sk->sk_state = ESTAB
#  sk->sk_rqueue = 0
#  sk->sk_wqueue = 0
#  sk->sk_allocs = 1
#  sk->sk_drops = 0
#  sk->sk_rcvbuf = 425984
#  sk->sk_sndbuf = 40960
#  sk->sk_state = ESTAB
#  sk->sk_rcv_ssthresh = 0
#  sk->sk_snd_ssthresh = 520
#  tcp_info: { state=01, ca_state=0, ... }
#  rto: 204/204, ato: 40, rcv_rtt: 12.5, rcv_space: 131240

4. TCP 性能调优实践

4.1 Linux 系统调优

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# /etc/sysctl.conf 调优

# 1. 扩大连接队列
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535

# 2. TIME_WAIT 调优
net.ipv4.tcp_tw_reuse = 1          # 复用 TIME_WAIT
net.ipv4.tcp_fin_timeout = 15      # 缩短 FIN 超时
net.ipv4.tcp_max_tw_buckets = 10000

# 3. 扩大端口范围
net.ipv4.ip_local_port_range = 1024 65535

# 4. TCP 缓冲区自动调优
net.core.rmem_default = 262144
net.core.rmem_max = 16777216
net.core.wmem_default = 262144
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 16384 16777216

# 5. 拥塞控制算法（现代服务器推荐）
net.ipv4.tcp_congestion_control = cubic  # 或 bbr
net.core.default_qdisc = fq              # Fair Queuing

# 6. 其他
net.ipv4.tcp_syncookies = 1             # SYN Flood 防护
net.ipv4.tcp_abort_on_overflow = 0      # 不立即 RST
net.ipv4.tcp_sack = 1                   # 启用 SACK

# 应用
sudo sysctl -p

4.2 BBR 拥塞控制

1
2
3
4
5
6
7
8
9
10
11
12
13
# 查看支持的拥塞控制算法
cat /proc/net/tcp_congestion_control_available
# bbr cubic reno

# 设置 BBR
sudo sysctl net.ipv4.tcp_congestion_control=bbr

# 验证
cat /proc/net/tcp_congestion_control
# bbr

# 查看是否启用
lsmod | grep bbr

BBR 优势（Google 开发）：

  • 基于带宽和延迟而非丢包检测拥塞
  • 在高丢包/高延迟网络中表现优异
  • 启动更快，吞吐更高

5. 实践：SO_REUSEPORT 负载均衡测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// reuseport_test.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>

#define PORT 8080
#define N_WORKERS 4

int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

void run_worker(int worker_id) {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port   = htons(PORT),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr));
    listen(listen_fd, 1024);

    int epfd = epoll_create1(0);
    set_nonblocking(listen_fd);

    struct epoll_event ev = {.events = EPOLLIN, .data.fd = listen_fd};
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);

    struct epoll_event events[64];

    while (1) {
        int n = epoll_wait(epfd, events, 64, 1000);
        for (int i = 0; i < n; i++) {
            int fd = events[i].data.fd;
            if (fd == listen_fd) {
                int conn = accept(listen_fd, NULL, NULL);
                if (conn >= 0) {
                    set_nonblocking(conn);
                    struct epoll_event ce = {.events = EPOLLIN, .data.fd = conn};
                    epoll_ctl(epfd, EPOLL_CTL_ADD, conn, &ce);
                }
            } else {
                char buf[1024];
                ssize_t len = read(fd, buf, sizeof(buf) - 1);
                if (len > 0) {
                    const char *resp =
                        "HTTP/1.1 200 OK\r\n"
                        "Content-Length: 14\r\n"
                        "\r\n"
                        "Hello Worker X";
                    char msg[64];
                    snprintf(msg, sizeof(msg),
                             "HTTP/1.1 200 OK\r\n"
                             "Content-Length: 15\r\n"
                             "\r\n"
                             "Worker %d handled", worker_id);
                    write(fd, msg, strlen(msg));
                }
                close(fd);
            }
        }
    }
}

int main() {
    printf("Starting %d workers with SO_REUSEPORT on port %d\n",
           N_WORKERS, PORT);
    printf("PID: %d\n", getpid());

    for (int i = 1; i < N_WORKERS; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            printf("Worker %d PID: %d\n", i, getpid());
            run_worker(i);
            return 0;
        }
    }

    // 主进程 worker 0
    printf("Worker 0 PID: %d\n", getpid());
    run_worker(0);
    return 0;
}
1
2
3
4
5
6
7
gcc -o reuseport_test reuseport_test.c
./reuseport_test &

# 压测
ab -n 10000 -c 100 http://localhost:8080/

# 验证负载均衡：不同 worker 处理了不同数量的请求
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870