3 Transport Layer

传输层的定位

网络层提供主机到主机的交付,传输层把它提升到进程到进程。

网络层:  把数据送到 93.184.216.34 这台机器
传输层:  把数据送到这台机器上的 443 端口(某个 socket)

这个提升靠的是端口号 + 传输层头部。除此之外,TCP 还在 IP 之上补了 IP 不提供的东西:可靠、按序、不重复、流量控制、拥塞控制。

复用与分用

  • 复用:多个应用进程的数据,加上传输层头后共用下面的网络层
  • 分用:接收端根据头部字段,把数据交给正确的 socket

UDP 分用:二元组 (dstIP, dstPort) —— 所有发到这个端口的都进同一个 socket。

TCP 分用:四元组 (srcIP, srcPort, dstIP, dstPort) —— 唯一确定一条连接。

四元组的意义:Web 服务器一个 443 端口能同时服务百万连接,因为客户端的 IP:port 组合各不相同。但单台客户端访问同一服务器时,源端口数量(约 6 万)就成了上限——这就是压测时需要多个客户端 IP 的原因。

UDP

头部:8 字节

 0      7 8     15 16    23 24    31
┌────────┬────────┬────────┬────────┐
│  源端口 │ 目的端口│  长度   │ 校验和 │
├────────┴────────┼────────┴────────┤
│      数据(如果有)               │
└──────────────────────────────────┘

就四个字段。长度包含头部,校验和在 IPv4 下可选(但几乎都开)、IPv6 下必选。

UDP 提供的和没提供的

提供:

  • 进程到进程的交付(端口号)
  • 差错检测(校验和)——检测到错就丢弃,不修

不提供:

  • 可靠性(丢了不管)
  • 按序(先发的可能后到)
  • 流量控制
  • 拥塞控制

为什么还需要 UDP

  1. 延迟敏感 > 丢失敏感:语音/视频,丢一帧无所谓(画面卡一下),等重传才是灾难(声音断开)
  2. 不需要连接建立:DNS 一次查询一次响应,握手反而占了一半开销
  3. 没有连接状态:服务器不用为每个对端维护状态,能支持更多客户端
  4. 头部小:8 字节 vs TCP 的 20+ 字节
  5. 应用层可以自己定制可靠性:QUIC、KCP、游戏的网络层都是这么干的

关键认知:UDP 不是"不可靠的 TCP",而是"把控制权交还给应用层的最小传输层"。要不要可靠、怎么可靠,由应用自己决定——这正是 QUIC 能取代 TCP 的原因。

TCP

头部

 0                   15 16                  31
┌─────────────────────┬─────────────────────┐
│      源端口          │      目的端口        │
├─────────────────────┴─────────────────────┤
│                 序号 seq                   │
├───────────────────────────────────────────┤
│               确认号 ack                   │
├────┬───┬───────┬───┬───┬───┬───┬───┬──────┤
│偏移│保留│ U A P R S F │       窗口          │
│    │   │ R C S S Y I │                     │
│    │   │ G K H T N N │                     │
├────┴───┴───────┴───┴───┴───┴───┴───┼──────┤
│         校验和                      │ 紧急指针│
├────────────────────────────────────┴──────┤
│              选项(MSS, SACK, 窗口扩大, 时间戳)│
└───────────────────────────────────────────┘

关键字段:

  • 序号 seq:本报文段第一个字节在字节流中的编号
  • 确认号 ack:期望收到的下一个字节编号(= 已收到的最后字节 + 1),累积确认
  • 窗口:接收窗口大小,用于流量控制
  • 标志位:SYN(建连)、FIN(优雅关闭)、RST(重置/拒绝)、ACK(确认有效)、PSH(立即推送给应用)、URG(紧急数据,基本废弃)

TCP 是字节流,不是消息流。序号按字节编号,不是按报文段。应用层 send() 的边界在 TCP 里不保留——这就是粘包/拆包问题的根源:

send(s, "hello", 5);
send(s, "world", 5);
// 对端可能一次 recv 到 "helloworld"

要保留消息边界,必须在应用层自己加长度前缀或分隔符。

Connection:三次握手

客户端                                  服务器
  │                                       │
  │──── SYN, seq=x ──────────────────────►│  CLOSED → SYN-SENT
  │                                       │  LISTEN → SYN-RCVD
  │◄─── SYN+ACK, seq=y, ack=x+1 ─────────│
  │     ESTABLISHED                       │  SYN-RCVD
  │──── ACK, ack=y+1 ────────────────────►│
  │                                       │  ESTABLISHED
  │════════════ 数据 ════════════════════►│

为什么是三次,不是两次?

两次握手(SYN → SYN+ACK,然后直接发数据)的问题:无法阻止历史重复连接。

1. 客户端发 SYN(x),但包在网络里滞留了
2. 客户端超时重发 SYN(x'),成功建立连接、传完数据、关闭
3. 那个滞留的旧 SYN(x) 终于到了服务器
4. 服务器以为是新连接,回 SYN+ACK 并分配资源
5. 客户端已经不认这个连接了 → 服务器白白维护一个死连接

有了第三次 ACK,客户端有机会确认"我确实要建立这个连接"。对于旧的重复 SYN,客户端不会回 ACK(序号对不上,会回 RST),服务器就不会建立死连接。

同时三次握手也交换了双方的初始序号(ISN),并协商了 MSS、窗口扩大因子、SACK 支持等选项。

ISN 为什么是随机的? 早期实现用固定起点,攻击者可以猜测序号伪造报文(TCP 序号预测攻击)。现代 OS 用随机化的 ISN。

四次挥手

主动方                                  被动方
  │──── FIN, seq=u ─────────────────────►│  ESTABLISHED → FIN-WAIT-1
  │                                       │  → CLOSE-WAIT
  │◄─── ACK, ack=u+1 ───────────────────│  FIN-WAIT-2
  │                                       │  (被动方可能还有数据要发)
  │◄─── FIN, seq=v, ack=u+1 ────────────│  → LAST-ACK
  │──── ACK, ack=v+1 ───────────────────►│  → CLOSED
  │     TIME-WAIT (2MSL)                  │
  │     → CLOSED                          │

为什么是四次? 因为 TCP 是全双工的,两个方向要分别关闭。被动方收到 FIN 时,可能还有数据没发完,所以 ACK 和 FIN 分开发。

TIME_WAIT 为什么要等 2MSL(Maximum Segment Lifetime,典型 60s)?

两个原因:

  1. 可靠地终止连接:最后一个 ACK 可能丢失,被动方会重发 FIN。如果主动方已关闭,就会回 RST,让对方异常终止
  2. 让旧连接的残余报文在网络中消散:防止这些报文被后续复用同一四元组的新连接误收

TIME_WAIT 只在主动关闭方出现。所以服务器大量 TIME_WAIT 通常意味着服务器主动关连接——可以改成让客户端主动关。

状态机

               CLOSED
                 │ 被动打开: listen()
                 ▼
              LISTEN ──── 收到 SYN, 发 SYN+ACK ──► SYN-RCVD
                 │                                    │
主动打开: connect()                        收到 ACK → ESTABLISHED
发 SYN │                                              │
       ▼                                              │
   SYN-SENT ──── 收到 SYN+ACK, 发 ACK ────────────────┘
                                                       │
                                     主动关闭: close(), 发 FIN
                                                       ▼
                                                  FIN-WAIT-1
                                                   │      │
                                   收到 ACK+FIN    │      │ 收到 ACK
                                   (同时)         │      ▼
                                                   │  FIN-WAIT-2
                                                   │      │ 收到 FIN, 发 ACK
                                                   ▼      ▼
                                                 TIME-WAIT ← CLOSING
                                                   │ 2MSL 超时
                                                   ▼
                                                 CLOSED

SYN-RCVD 状态的半连接队列是 SYN Flood 攻击的目标:攻击者只发 SYN 不回 ACK,耗尽队列。解法是 SYN Cookie(不分配资源,用序号编码连接信息)。

可靠传输

TCP 用累积确认 + 超时重传,并在实践中加了若干增强:

1. 超时重传(RTO)

RTO=SRTT+4×RTTVAR\text{RTO} = \text{SRTT} + 4 \times \text{RTTVAR}

SRTT=(1−α)SRTT+α⋅RTTsample,α=1/8RTTVAR=(1−β)RTTVAR+β⋅∣SRTT−RTTsample∣,β=1/4\begin{aligned} \text{SRTT} &= (1-\alpha)\text{SRTT} + \alpha \cdot \text{RTT}_{sample}, \quad \alpha = 1/8 \\ \text{RTTVAR} &= (1-\beta)\text{RTTVAR} + \beta \cdot |\text{SRTT} - \text{RTT}_{sample}|, \quad \beta = 1/4 \end{aligned}

用指数加权移动平均估计 RTT,方差项处理抖动。超时后 RTO 指数退避(×2),因为超时可能意味着网络严重拥塞。

2. 快速重传(Fast Retransmit)

不等超时。收到 3 个重复 ACK 就立即重传丢失的段。

为什么是 3 个?因为乱序(而非丢包)也会产生重复 ACK,但很少会连续产生 3 个。3 是一个"大概率真丢了"的经验阈值。

发送: [1][2][3][4][5][6]
              ↑ 丢了
收到: 1, 2,然后 4,5,6 → 每个都触发 "我要 3" 的重复 ACK
                        → 3 个 dupACK → 立即重传 3(不等 200ms 的 RTO)

3. SACK(Selective Acknowledgment)

累积确认只说"我收到到哪了",不知道后面哪些到了。SACK 让接收方在选项里报告已收到的不连续区间,发送方可以只重传真正丢的。

SACK: [左边界1-右边界1][左边界2-右边界2]...

没有 SACK 时,一个窗口里丢两个包会导致大量不必要的重传。SACK 是 TCP 性能的重要增强(现代 OS 都开了)。

4. Nagle 算法与延迟 ACK

Nagle:一个连接上最多只能有一个未被确认的小报文;在该 ACK 到达前,后续小数据被缓存合并。

目的:防止"糊涂窗口综合症"——应用每次只发 1 字节,40 字节头部 + 1 字节数据, overhead 4000%。

延迟 ACK:收到数据后不立即 ACK,等 40ms(或等有数据要回发时捎带)。

两者一起用会死锁:Nagle 等 ACK,延迟 ACK 等数据 → 卡 40ms。所以对延迟敏感的应用要开 TCP_NODELAY(关 Nagle)。游戏、RPC、实时通信都应该设 TCP_NODELAY。

流量控制(Flow Control)

目的:别让发送方发得比接收方处理得快。

机制:滑动窗口。接收方在每个 ACK 里通告 rwnd(接收窗口 = 接收缓冲区剩余空间):

发送方未确认数据量≤rwnd\text{发送方未确认数据量} \leq \text{rwnd}

已确认 │  已发送未确认   │ 可立即发送 │ 不可发送
       ▲                ▲            ▲
    SendBase       SendBase+N    SendBase+N+rwnd

糊涂窗口综合症(Silly Window Syndrome):接收方每次只腾出几字节就通告,发送方就发几个字节的小包。解法:接收方等到窗口 ≥ MSS 或 ≥ 缓冲区一半才通告非零窗口。

流量控制 vs 拥塞控制要分清:

  • 流量控制:保护接收方(端到端,由 rwnd 决定)
  • 拥塞控制:保护网络(全局,由 cwnd 决定)

实际发送上限:min⁡(cwnd,rwnd)\min(\text{cwnd}, \text{rwnd})。

拥塞控制

TCP 的最大特色:发送方根据观测到的网络状况主动降速。这是互联网没有崩溃的关键。

核心思想:把丢包(或延迟上升)当作拥塞信号,据此调整 cwnd(拥塞窗口)。

经典四阶段(Reno)

cwnd
 ▲
 │            ┌──── 拥塞避免(每 RTT +1 MSS,线性)
 │           /
 │          /
 │         /    ← 阈值 ssthresh
 │        /
 │       ╱  快速恢复
 │      ╱
 │     ╱
 │    ╱
 │   ╱   慢启动(每 RTT ×2,指数)
 │  ╱
 │ ╱
 └────────────────────────────► 时间

慢启动(Slow Start):

  • 初始 cwnd = 1 MSS(现在标准是 10 MSS)
  • 每收到一个 ACK,cwnd += 1 MSS
  • 效果:每 RTT 翻倍,指数增长
  • 虽然叫"慢启动",其实增长很快——只是起点低

拥塞避免:

  • 当 cwnd >= ssthresh(慢启动阈值,初始通常 64 KB)
  • 每收到一个 ACK,cwnd += MSS × MSS / cwnd
  • 效果:每 RTT +1 MSS,线性增长

降速规则:

  • 超时(严重拥塞):ssthresh = cwnd/2,cwnd = 1,重新慢启动
  • 3 个重复 ACK(轻度拥塞,还能收到包说明网络还能传):ssthresh = cwnd/2,cwnd = ssthresh + 3,进入快速恢复

为什么超时比丢包处罚重得多?因为超时意味着连 ACK 都回不来了,网络状况显然更糟。

吞吐公式

吞吐≈0.75×WRTT\text{吞吐} \approx \frac{0.75 \times \text{W}}{\text{RTT}}

其中 W 是平均窗口大小(0.750.75 来自 AIMD 的锯齿形平均)。

反直觉推论:高带宽长距离链路(大 BDP)很难跑满。

BDP=带宽×RTT\text{BDP} = \text{带宽} \times \text{RTT}

例:1 Gbps × 100 ms = 12.5 MB。窗口必须能开到 12.5 MB 才能跑满——但 TCP 头部窗口字段只有 16 bit,最大 65535 字节!这就是**窗口扩大选项(Window Scaling)**存在的原因(最大可扩到 1 GB)。

BIC / CUBIC

Reno 在高 BDP 网络下恢复太慢(线性增长从 1 开始要很久)。CUBIC 用三次函数控制窗口:

W(t)=C(t−K)3+Wmax,K=Wmax(1−β)C3W(t) = C(t - K)^3 + W_{max}, \quad K = \sqrt[3]{\frac{W_{max}(1-\beta)}{C}}

特点:

  • 靠近WmaxW_{max} 时增长慢(凸),远离时增长快(凹)——独立于 RTT,比 Reno 公平
  • Linux 默认算法

BBR

根本性的思路转变:Reno/CUBIC 把丢包当拥塞信号,BBR 认为这已经过时了(现代网络有很深的缓冲区,丢包发生得太晚)。

BBR 主动测量两个量:

  • BtlBw(瓶颈带宽):最大交付速率
  • RTprop(往返传播延迟):最小 RTT

然后让发送速率 = BtlBw,在途数据量 = BDP = BtlBw × RTprop。

理想的在途数据量=BtlBw×RTprop\text{理想的在途数据量} = \text{BtlBw} \times \text{RTprop}

优点:

  • 在有一定丢包率(非拥塞导致)的链路上吞吐远高于 CUBIC(YouTube 用 BBR 后吞吐提升显著)
  • 不会因为深缓冲区而把延迟拉到几百 ms(bufferbloat 问题)

缺点:

  • 与 CUBIC 共存时会抢占带宽(公平性问题)
  • 对无线网络(带宽剧烈变化)响应有滞后

TCP 的性能问题总结

问题表现缓解
握手延迟每个新连接 1-RTT长连接、连接池、TCP Fast Open
队头阻塞一个包丢,后面全等HTTP/2 多流仍受阻 → QUIC
慢启动短连接跑不满带宽连接复用、调大初始 cwnd
Nagle + 延迟 ACK40ms 额外延迟TCP_NODELAY
队头阻塞(内核)乱序时数据不能交给应用无解,TCP 语义决定的

核心矛盾:TCP 的可靠 + 按序语义,要求"前面的字节没到,后面的不能交给应用"。这在多流复用时会让所有流一起卡住。这是协议设计层面的限制,补丁解决不了——所以 Google 做了 QUIC。

KCP

KCP 是一个在 UDP 之上实现的可靠传输协议,由国内开发者 skywind 编写,在游戏和实时通信领域广泛使用。

设计目标

以带宽换延迟。在同样条件下,KCP 的延迟通常比 TCP 低 30%~40%,代价是多消耗 10%~20% 带宽。

与 TCP 的关键差异

机制TCPKCP
RTO 退避超时 ×2×1.5(可配置,模式里可不退避)
快速重传3 个 dupACK可配 1~2 个
重传策略只重传真正丢失的可选重传该包之后的全部(激进模式)
延迟 ACK有(40ms)无,立即 ACK
拥塞控制完整的慢启动/拥塞避免可关闭,只做流量控制
流控有可关闭(游戏场景追求低延迟)

模式配置

// 默认模式(类似 TCP,公平性较好)
ikcp_nodelay(kcp, 0, 40, 0, 0);

// 极速模式:nodelay=1, interval=10ms, resend=2, nc=1
ikcp_nodelay(kcp, 1, 10, 2, 1);

参数:nodelay(是否启用 nodelay)、interval(内部刷新间隔)、resend(快速重传的 dupACK 阈值)、nc(是否关闭拥塞控制)。

为什么游戏用 KCP

游戏网络的特征:

  • 小包高频:每帧几十字节的状态同步
  • 延迟极度敏感:>150ms 手感就差
  • 丢一点无所谓,但迟到的数据没用(过期的状态包毫无价值)

TCP 的"严格按序 + 丢包退避"在这种场景下是灾难:丢一个包,后面 100ms 的数据全部等待。

KCP 的做法:

  • 丢包立刻重传(不等 RTO 指数退避)
  • 可选择性地跳过等待,让应用层拿到"最新但可能不完整"的数据
  • 关闭拥塞控制(局域网/专线的丢包不是拥塞导致的,降速没意义)

注意事项

  • KCP 不是 TCP 的替代品,是特定场景的优化。公网大流量传输还是 TCP/BBR 更合适(要考虑公平性)
  • 用 UDP 会被某些网络设备 QoS 限速
  • 需要自己在应用层处理 MTU 分片(KCP 有分片机制)

QUIC

QUIC(Quick UDP Internet Connections)由 Google 设计,2015 年提出,2021 年成为 RFC 9000,是 HTTP/3 的底层协议。

为什么要在 UDP 上重造 TCP

TCP 的三个根本问题:

  1. 队头阻塞:内核 TCP 保证按序,一个流丢包会卡住该连接上所有流
  2. 握手延迟:TCP + TLS 要 2~3 个 RTT 才能发数据
  3. 僵化(ossification):TCP 在内核里,中间网络设备(NAT、防火墙)会检查甚至修改 TCP 头,改 TCP 几乎不可能部署

QUIC 的解法:放在 UDP 之上的用户态。UDP 头足够简单,中间设备只看它;QUIC 自己的头部是加密的,可以任意演进。

关键特性

1. 连接建立快

TCP + TLS 1.2:  TCP 握手(1 RTT) + TLS 握手(2 RTT) = 3 RTT
TCP + TLS 1.3:  TCP 握手(1 RTT) + TLS 握手(1 RTT) = 2 RTT
QUIC 首次:      合并的握手 = 1 RTT
QUIC 重连:      0-RTT(用上次会话的密钥直接发数据)

0-RTT 是 QUIC 最实用的特性:回访网站时,第一个数据包就带上 HTTP 请求,不用等握手。

代价:0-RTT 数据不保证语义安全(可被重放)。所以只能用于幂等操作,不能用于转账。

2. 多路复用且无队头阻塞

QUIC 在一条连接上开多个流(stream),每条流独立编号、独立确认:

QUIC 连接
├── Stream 1(HTML)   独立序号、独立流控
├── Stream 3(CSS)
├── Stream 5(JS)
└── Stream 7(图片)

Stream 3 丢包,只影响 Stream 3。TCP 上所有流共用一个字节流序号,一个丢全卡;QUIC 每个流独立,彻底解决。

3. 连接迁移

TCP 连接由四元组标识。手机从 WiFi 切到 4G,IP 变了,连接就断了,要重新握手。

QUIC 用 Connection ID 标识连接,与 IP 无关:

切换网络 → IP 变了 → Connection ID 不变 → 连接继续,不中断

这对移动端是巨大提升(走进电梯、出电梯、切 WiFi,视频通话不掉线)。

4. 头部加密

QUIC 除了少数必须的字段(Connection ID、版本号),所有头部都加密,包括包序号。

好处:

  • 防止中间设备窥探和篡改
  • 防止协议僵化——中间设备看不到,就没法依赖它的格式,QUIC 可以自由演进

这是吸取了 TCP 教训的设计决策。

5. 灵活的拥塞控制

拥塞控制在用户态,可以换算法、可以按连接定制,不用改内核。默认用 CUBIC,也可以换成 BBR。

6. 前向纠错(FEC)

可选特性:发送冗余数据,丢失少量包时不重传直接恢复。适合实时场景,代价是带宽。

QUIC 的现状与问题

  • 已被 HTTP/3 采用,Chrome/Firefox/Safari 和主流 CDN 都支持
  • 部署率已超过 30% 的网站
  • 问题:
    • 有些网络/防火墙会拦 UDP 443
    • CPU 开销比 TCP 高(用户态加密 + 更多处理)
    • 0-RTT 的重放风险

三者对比

维度TCPUDPKCPQUIC
可靠性✓✗✓✓
按序✓✗✓按流按序
队头阻塞严重无无无(按流隔离)
拥塞控制内核,完整无可选用户态,可换
握手1 RTT无无1 RTT / 0-RTT
连接迁移✗—✗✓
部署位置内核内核用户态用户态
典型场景Web、文件DNS、音视频游戏、实时HTTP/3

常见坑

  • 把"TCP 保证送达"理解成"应用一定收到":TCP 只保证"尽最大努力送到对端内核缓冲区",对端进程崩溃了照样丢
  • 用了 SO_REUSEADDR 就以为是 SO_REUSEPORT:前者允许绑 TIME_WAIT 地址,后者才允许多个 socket 绑同一端口做负载均衡
  • 压测时源端口耗尽:单个客户端对同一服务器最多约 6 万并发连接(16 bit 端口上限)
  • TIME_WAIT 恐慌:现代 Linux 上几十万 TIME_WAIT 不是问题。真正该做的是用长连接
  • KCP 关了拥塞控制后跑公网:会造成网络拥塞,且不友好。公网请保留
  • 以为 QUIC 一定更快:高丢包网络(如弱网 4G)上 QUIC 优势明显(可达 30%+ 提升);网络很好时优势主要来自 0-RTT,可能只有几十 ms
  • UDP 也要处理 MTU:超过 MTU 会在 IP 层分片,任一片丢失整个包就废了。建议 控制在 1200 字节以内(QUIC 的推荐值,兼容最小 MTU 场景)