Update 计算机网络 - 传输层.md

调整高频标记;TCP 与 UDP 的选择、TIME_WAIT、流量控制与拥塞控制、粘包与拆包等小节的补充,新增附录 A9 粘包与拆包。
This commit is contained in:
CyC2018
2026-11-07 17:10:31 +08:00
parent c3984a9aaa
commit 7258ad8092
+85 -32
View File
@@ -17,7 +17,7 @@
* [超时重传时间](#超时重传时间)
* [TCP 滑动窗口](#tcp-滑动窗口)
* [TCP 流量控制](#tcp-流量控制)
* [TCP 拥塞控制](#tcp-拥塞控制) 🔥🔥
* [TCP 拥塞控制](#tcp-拥塞控制) 🔥
* [1. 慢开始与拥塞避免](#1-慢开始与拥塞避免)
* [2. 快重传与快恢复](#2-快重传与快恢复)
* [TCP 粘包与拆包](#tcp-粘包与拆包)
@@ -31,6 +31,7 @@
* [A6 快重传与 SACK](#a6-快重传与-sack)
* [A7 零窗口与窗口探测](#a7-零窗口与窗口探测)
* [A8 全连接队列已满](#a8-全连接队列已满)
* [A9 粘包与拆包](#a9-粘包与拆包)
* [参考资料](#参考资料)
<!-- GFM-TOC -->
@@ -41,8 +42,8 @@
## UDP 和 TCP 的特点 🔥🔥
- 用户数据报协议 UDP(User Datagram Protocol)是无连接的,尽最大可能交付,没有拥塞控制,面向报文(对于应用程序传下来的报文不合并也不拆分,只是添加 UDP 首部),支持一对一、一对多、多对一和多对多的交互通信;
- 传输控制协议 TCP(Transmission Control Protocol)是面向连接的,提供可靠交付(实现方法见 [TCP 可靠传输](#tcp-可靠传输)),有流量控制,拥塞控制,提供全双工通信,面向字节流(把应用层传下来的报文看成字节流,把字节流组织成大小不等的数据块,不保留消息边界,见 [TCP 粘包与拆包](#tcp-粘包与拆包)),每一条 TCP 连接只能是点对点的(一对一)。
- 用户数据报协议 UDP(User Datagram Protocol)是无连接的,尽最大可能交付(不确认、不重传,数据报可能丢失、重复或乱序),没有拥塞控制,面向报文(对于应用程序传下来的报文不合并也不拆分,只是添加 UDP 首部),支持一对一、一对多、多对一和多对多的交互通信;
- 传输控制协议 TCP(Transmission Control Protocol)是面向连接的,提供可靠交付(实现方法见 [TCP 可靠传输](#tcp-可靠传输)),有[流量控制](#tcp-流量控制)、[拥塞控制](#tcp-拥塞控制),提供全双工通信,面向字节流(把应用层传下来的报文看成字节流,把字节流组织成大小不等的数据块,不保留消息边界,见 [TCP 粘包与拆包](#tcp-粘包与拆包)),每一条 TCP 连接只能是点对点的(一对一)。
UDP 延迟低,不是因为它发得更快,而是省掉了 TCP 为可靠付出的等待:不需要握手,第一个数据报就带着数据;丢包时不等重传,后面的数据照常交给应用;没有拥塞控制,不会因为丢包而主动降低发送速率;首部只有 8 字节,TCP 至少 20 字节。需要注意的是,这也意味着网络拥塞时,UDP 应用要自己控制发送速率,否则会加重拥塞。
@@ -54,11 +55,11 @@ TCP 的可靠和按序是有代价的:一个报文段丢失后,后面已经
- 数据过时就没有用、宁可丢掉的场景用 UDP,例如实时对战游戏的位置同步、视频通话(WebRTC 优先使用 UDP);
- 只有一问一答的场景用 UDP 可以省去握手,例如 DNS 查询。
直播常用的 HLS 基于 HTTP 分发视频分片,通常运行在 TCP 上,观众能接受几秒的延迟,换来画面完整。
直播常用的 HTTP 直播流(HTTP Live Streaming, HLS)基于 HTTP 分发视频分片,通常运行在 TCP 上,观众通常能接受十几秒以上的延迟,换来画面完整。
DNS 也不是只用 UDP。不带 EDNS 扩展时,UDP 上的 DNS 响应限制为 512 字节,超出时服务器只返回放得下的部分并设置 TC(截断)标志,客户端改用 TCP 重新查询;主从 DNS 服务器之间同步整个区域的数据(区域传送)也用 TCP。例如不带 EDNS 查询 google.com 的 TXT 记录,UDP 响应被截断,dig 改用 TCP 后收到 1176 字节的完整响应(实测,见[附录 A5](#a5-dns-改用-tcp))。RFC 7766 要求 DNS 实现同时支持 UDP 和 TCP。
DNS 也不是只用 UDP。不带 EDNS 扩展(DNS 的扩展机制,可以声明能接收更大的 UDP 响应)时,UDP 上的 DNS 响应限制为 512 字节,超出时服务器只返回放得下的部分并设置 TC(截断)标志,客户端改用 TCP 重新查询;主从 DNS 服务器之间同步整个区域的数据(区域传送)也用 TCP。例如不带 EDNS 查询 google.com 的 TXT 记录,UDP 响应被截断,dig 改用 TCP 后收到 1176 字节的完整响应(实测,见[附录 A5](#a5-dns-改用-tcp))。RFC 7766 要求 DNS 实现同时支持 UDP 和 TCP。
例如游戏客户端每 50 ms 上报一次位置,在 RTT 为 50 ms、丢包率为 5% 的网络中分别用 TCP 和 UDP 发送 600 次(Linux 实测,见[附录 A1](#a1-tcp-与-udp-发送位置更新)):
以位置同步为例,游戏客户端每 50 ms 上报一次位置,在往返时间(Round-Trip Time, RTT)为 50 ms、丢包率为 5% 的网络中分别用 TCP 和 UDP 发送 600 次(Linux 实测,见[附录 A1](#a1-tcp-与-udp-发送位置更新)):
<div align="center"> <img src="pics/tcp-udp-latency.png" width="760px"/> </div><br>
@@ -70,7 +71,7 @@ DNS 也不是只用 UDP。不带 EDNS 扩展时,UDP 上的 DNS 响应限制为
<div align="center"> <img src="pics/udp-header.png" width="600px"/> </div><br>
首部字段只有 8 个字节,包括源端口、目的端口、长度、检验和。12 字节的伪首部是为了计算检验和临时添加的。
首部字段只有 8 个字节,包括源端口、目的端口、长度、检验和。IPv4 中 12 字节的伪首部是为了计算检验和临时添加的。
## TCP 首部格式
@@ -108,13 +109,13 @@ DNS 也不是只用 UDP。不带 EDNS 扩展时,UDP 上的 DNS 响应限制为
<div align="center"> <img src="pics/tcp-stale-syn.png" width="600px"/> </div><br>
B 照常回复 SYN+ACK。A 并没有在等这个连接,回复 RST(复位报文段,告诉对方这个连接不存在),B 收到后放弃这个半连接。如果只有两次握手,B 发出 SYN+ACK 就认为连接已经建立,为它分配资源,等待一个永远不会来的请求。A 已经重新发起连接时,这个确认对不上 A 正在进行的连接,A 同样回复 RST,B 不会多打开一个连接。
B 照常回复 SYN+ACK。A 并没有在等这个连接,回复 RST(复位报文段,告诉对方这个连接不存在),B 收到后放弃这个还没有完成握手的连接(半连接)。如果只有两次握手,B 发出 SYN+ACK 就认为连接已经建立,为它分配资源,等待一个永远不会来的请求。A 已经重新发起连接时,这个确认对不上 A 正在进行的连接,A 同样回复 RST,B 不会多打开一个连接。
### 握手报文丢失
每个握手报文都可能丢失,丢失后靠超时重传恢复(Linux 6.10 实测,见[附录 A2](#a2-握手报文丢失)):
- 第一次握手的 SYN 丢失:客户端收不到 SYN+ACK,超时后重传 SYN。Linux 6.5 之前按 tcp_syn_retries(默认 6)重传,间隔从 1 秒起每次翻倍,约 127 秒后放弃;6.5 起增加了 tcp_syn_linear_timeouts(默认 4)次按固定间隔的重传,前 5 次重传的间隔都是 1 秒,之后再翻倍,共重传 10 次,内核文档给出约 131 秒后放弃,实测 134 秒后 connect() 返回超时错误;
- 第一次握手的 SYN 丢失:客户端收不到 SYN+ACK,超时后重传 SYN。Linux 6.5 之前按 tcp_syn_retries(默认 6)重传,间隔从 1 秒起每次翻倍,最后一次重传后再等 64 秒,约 127 秒后放弃;6.5 起增加了 tcp_syn_linear_timeouts(默认 4)次按固定间隔的重传,前 5 次重传的间隔都是 1 秒,之后再翻倍,共重传 10 次,内核文档给出约 131 秒后放弃,实测 134 秒后 connect() 返回超时错误;
- 第二次握手的 SYN+ACK 丢失:客户端以为 SYN 丢了,重传 SYN;服务器收不到第三次握手,也重传 SYN+ACK(tcp_synack_retries 默认 5 次,间隔 1、2、4、8、16 秒),任何一方的重传到达,连接都能建立;
- 第三次握手的 ACK 丢失:客户端发出 ACK 后已经进入 ESTABLISHED,服务器仍处于 SYN_RCVD,继续重传 SYN+ACK,客户端每收到一次就再回复一次 ACK。客户端发送的数据报文段也带有 ACK,服务器收到后同样会建立连接;如果这些 ACK 都丢失、客户端也一直不发数据,服务器重传 5 次后放弃,删除这个半连接,并不通知客户端,之后客户端再发数据会收到 RST。
@@ -186,10 +187,10 @@ ss -tan | awk 'NR > 1 {print $1}' | sort | uniq -c
解决方案:
- 使用长连接或连接池,例如 [HTTP 的长连接](HTTP.md#1-短连接与长连接)、数据库连接池;
- 在发起连接的一方开启 net.ipv4.tcp_tw_reuse,允许新连接复用处于 TIME_WAIT 的端口,它依靠 TCP 时间戳选项识别旧连接的报文(Linux 默认值为 2,只对回环地址生效,设为 1 才对所有出站连接生效);
- 在发起连接的一方开启 net.ipv4.tcp_tw_reuse,允许新连接复用处于 TIME_WAIT 的端口,它依靠 TCP 时间戳选项(见[超时重传时间](#超时重传时间))识别旧连接的报文(Linux 默认值为 2,只对回环地址生效,设为 1 才对所有出站连接生效);
- 扩大本地端口范围 net.ipv4.ip_local_port_range。
Linux 没有提供修改 TIME_WAIT 时长的参数,缩短它也会让旧连接的报文段更容易混进新连接。另一个参数 tcp_tw_recycle 在 NAT 环境下会丢弃正常的连接:开启后内核按对端 IP 缓存最近收到的时间戳,缓存未过期时,时间戳回退超过容忍范围的 SYN 会被丢弃,而 NAT 后面多台主机的时间戳互不相关。Linux 4.10 起每个连接的时间戳还加了随机偏移,同一台主机的连接也可能被误丢,4.12 将这个参数移除。
Linux 没有提供修改 TIME_WAIT 时长的参数,缩短它也会让旧连接的报文段更容易混进新连接。另一个参数 tcp_tw_recycle 在 NAT 环境下会丢弃正常的连接:开启后内核按对端 IP 缓存最近收到的时间戳,缓存未过期时,时间戳回退超过容忍范围的 SYN 会被丢弃,而 NAT 后面多台主机的时间戳互不相关。Linux 4.10 给每个连接的时间戳加了随机偏移,同一台主机的连接也可能被误丢;4.11 改为按源、目的地址计算偏移,4.12 将这个参数移除。
CLOSE_WAIT 出现在被动关闭的一方,表示对方已经关闭,本方的应用还没有调用 close()。连接大量停在 CLOSE_WAIT 通常是程序的问题,例如异常分支没有关闭连接、从连接池借出的连接没有归还,或者处理线程被没有超时的慢调用占住,排队的连接一直等不到处理。这些连接会一直占用文件描述符,积累到上限后出现 Too many open files。
@@ -216,7 +217,7 @@ TCP 的确认是累积的:确认号为 N 表示 N 之前的字节都已收到
SACK 是握手时协商的选项,确认中额外携带已经收到的区间。上例中 SACK 2001~8000 告诉发送方只缺 1001~2000,发送方只重传这一段;没有 SACK 时,发送方只知道 1001 之后有缺失,不知道后面哪些已经到达。
在 Linux 上丢弃第 2 段,抓包结果与上面一致:接收方发出 1 个确认和 6 个重复确认,SACK 区间逐步扩大到 2001~8000,发送方在第 2 段首次发出后约 28 ms 重传,远小于 200 ms 的最小超时时间(Linux 6.10 实测,见[附录 A6](#a6-快重传与-sack))。快重传之后拥塞窗口的变化见[快重传与快恢复](#2-快重传与快恢复)。
在 Linux 上丢弃第 2 段,抓包结果与上面一致:接收方发出 1 个确认和 6 个重复确认,SACK 区间逐步扩大到 2001~8000,发送方在第 2 段首次发出后约 28 ms 重传,远小于 200 ms 的[最小超时时间](#超时重传时间)(Linux 6.10 实测,见[附录 A6](#a6-快重传与-sack))。快重传之后拥塞窗口的变化见[快重传与快恢复](#2-快重传与快恢复)。
### 超时重传时间
@@ -236,7 +237,7 @@ RTTs = (1 - a) × RTTs + a × RTT
RTO = RTTs + 4 × RTTd
```
其中 RTTd 为新测得的 RTT 与更新前的 RTTs 之差的绝对值的加权平均值,每次先更新 RTTd 再更新 RTTs;第一次测量时 RTTs 取 RTT,RTTd 取 RTT / 2。RFC 6298 建议 a 取 1/8,计算 RTTd 时的权重取 1/4,并建议 RTO 不小于 1 秒;Linux 的下限为 200 ms。
其中 RTTd 为新测得的 RTT 与更新前的 RTTs 之差的绝对值的加权平均值,即 RTTd = (1 − b) × RTTd + b × |RTTs − RTT|,每次先更新 RTTd 再更新 RTTs;第一次测量时 RTTs 取 RTT,RTTd 取 RTT / 2。RFC 6298 建议 a 取 1/8,b 取 1/4,并建议 RTO 不小于 1 秒;Linux 默认的下限为 200 ms。
例如先后测得的 RTT 为 100、120、300、110 ms,按 RFC 6298 计算如下(单位 ms,不计 1 秒的下限,|RTTs − RTT| 用的是更新前的 RTTs):
@@ -263,7 +264,7 @@ RTT 稳定时 RTO 逐渐向 RTT 靠拢;一次 300 ms 的抖动让偏差项变
发送窗口内的字节都允许发送,接收窗口内的字节都允许接收。发送窗口左端的字节收到确认后,窗口向右滑动,直到左端是第一个还没有被确认的字节;接收窗口左端的字节按序收到并确认后,接收窗口同样向右滑动。
接收窗口只会对窗口内最后一个按序到达的字节进行确认,例如接收窗口已经收到的字节为 {31, 34, 35},其中 {31} 按序到达,而 {34, 35} 就不是,因此只对字节 31 进行确认,确认号为 32。发送方得到一个字节的确认之后,就知道这个字节之前的所有字节都已经被接收。图中假设 B 的应用及时读走数据,通告的窗口一直是 10;应用不读取时窗口会缩小,见[流量控制](#tcp-流量控制)。
接收窗口只会对窗口内最后一个按序到达的字节进行确认,例如接收窗口已经收到的字节为 {31, 34, 35},其中 {31} 按序到达,而 {34, 35} 就不是,因此只对字节 31 进行确认,确认号为 32([累积确认](#确认与重传))。图中假设 B 的应用及时读走数据,通告的窗口一直是 10;应用不读取时窗口会缩小,见[流量控制](#tcp-流量控制)。
<div align="center"> <img src="pics/tcp-sliding-window.png" width="760px"/> </div><br>
@@ -279,15 +280,15 @@ RTT 稳定时 RTO 逐渐向 RTT 靠拢;一次 300 ms 的抖动让偏差项变
0.042 5792
0.083 1448
0.124 0 客户端停止发送
0.34、0.77、1.69 0 客户端发送零窗口探测,回复的窗口仍为 0
0.34、0.77、1.69 0 客户端发送零窗口探测,0.34 和 1.69 的回复中窗口仍为 0
3.002 15928 服务器读走数据,客户端立即恢复发送
```
窗口为 0 时,发送方启动持续计时器,定期发送零窗口探测报文段,间隔逐次翻倍,对方收到后必须回复当前的窗口。这是因为窗口更新报文不携带数据,丢失后不会重传,如果发送方只是等待,双方就会一直互相等待。
窗口为 0 时,发送方启动持续计时器,定期发送零窗口探测报文段,间隔逐次翻倍,规范要求对方收到后回复当前的窗口(Linux 对这类回复限速,个别探测可能收不到回复,见[附录 A7](#a7-零窗口与窗口探测))。这是因为窗口更新报文不携带数据,丢失后不会重传,如果发送方只是等待,双方就会一直互相等待。
首部的窗口字段只有 16 位,最大 65535 字节。在带宽大、延迟高的网络中不够用,例如 RTT 为 100 ms 时,64 KB 的窗口最多只能达到约 5 Mbit/s,而 1 Gbit/s 的链路一个 RTT 内可以发出 12.5 MB,即带宽 × RTT(带宽时延积),窗口至少要这么大才能跑满链路。窗口扩大选项在握手时协商一个移位数,实际窗口为窗口字段左移这么多位,移位数最大为 14,窗口最大约 1 GB。
## TCP 拥塞控制 🔥🔥
## TCP 拥塞控制 🔥
如果网络出现拥塞,分组将会丢失,此时发送方会继续重传,从而导致网络拥塞程度更高。因此当出现拥塞时,应当控制发送方的速率。这一点和流量控制很像,但是出发点不同。流量控制是为了让接收方能来得及接收,而拥塞控制是为了降低整个网络的拥塞程度。
@@ -308,9 +309,9 @@ TCP 主要通过四个算法来进行拥塞控制:慢开始、拥塞避免、
### 1. 慢开始与拥塞避免
发送的最初执行慢开始,令 cwnd = 1,发送方只能发送 1 个报文段;每收到一个对新数据的确认,cwnd 加 1,一个轮次发出的报文段都被确认后 cwnd 就翻了一倍,因此之后每个轮次能够发送的报文段数量为:2、4、8 ...
发送的最初执行慢开始,令 cwnd = 1,发送方只能发送 1 个报文段;每收到一个对新数据的确认,cwnd 加 1,一个轮次(约一个 RTT)发出的报文段都被确认后 cwnd 就翻了一倍,因此之后每个轮次能够发送的报文段数量为:2、4、8 ...
实际实现中初始拥塞窗口通常更大,RFC 6928 建议初始值为 10 个报文段。
实际实现中初始拥塞窗口通常更大,RFC 6928 把初始窗口的上限提高到 10 个报文段,Linux 的默认值就是 10。
慢开始每个轮次都将 cwnd 加倍,增长很快,很容易造成拥塞。因此设置一个慢开始门限 ssthresh,当 cwnd \>= ssthresh 时,进入拥塞避免,每个轮次只将 cwnd 加 1。
@@ -328,13 +329,13 @@ TCP 主要通过四个算法来进行拥塞控制:慢开始、拥塞避免、
慢开始和快恢复的快慢指的是 cwnd 的设定值,而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1,而快恢复 cwnd 设定为 ssthresh。
以上是经典的 Reno 算法(RFC 5681)。Linux、Windows 和 Apple 的协议栈默认使用的是 CUBIC(RFC 9438),它保留了慢开始和快重传,区别在拥塞避免阶段:cwnd 按距离上次丢包的时间的三次函数增长,先快速回到丢包前的大小,在附近放慢,然后再加速探测更大的带宽,在带宽大、延迟高的网络中比每轮加 1 增长得快。Google 的 BBR 则不再把丢包作为主要的拥塞信号,而是根据测得的瓶颈带宽和最小 RTT 来控制发送速率。
以上是经典的 Reno 算法(RFC 5681)。Linux、Windows 和 Apple 的协议栈默认使用的是 CUBIC(RFC 9438),它保留了慢开始和快重传,区别在于丢包后的减小幅度和拥塞避免阶段的增长方式:ssthresh 降为 cwnd 的 0.7 倍而不是一半;拥塞避免阶段 cwnd 按距离上次丢包的时间的三次函数增长,先快速回到丢包前的大小,在附近放慢,然后再加速探测更大的带宽,在带宽大、延迟高的网络中比每轮加 1 增长得快。Google 的 BBR 则不再把丢包作为主要的拥塞信号,而是根据测得的瓶颈带宽和最小 RTT 来控制发送速率。
## TCP 粘包与拆包
TCP 面向字节流,只保证字节按顺序到达,不保留应用每次写入的边界。发送方写入两次,接收方的一次读取可能读到两条消息拼在一起,称为粘包;也可能只读到一条消息的一部分,称为拆包(也叫半包)。
例如客户端依次写入 hello、world 和一条 200000 字节的消息,服务器等待 200 ms 后,先用 1024 字节的缓冲区读一次,再用 300000 字节的缓冲区读完剩下的数据:
例如客户端依次写入 hello、world 和一条 200000 字节的消息,服务器等待 200 ms 后,先用 1024 字节的缓冲区读一次,再用 300000 字节的缓冲区读完剩下的数据(JDK 21、macOS 实测,见[附录 A9](#a9-粘包与拆包)):
<div align="center"> <img src="pics/tcp-sticky.png" width="760px"/> </div><br>
@@ -344,9 +345,9 @@ TCP 面向字节流,只保证字节按顺序到达,不保留应用每次写
- 发送方的 Nagle 算法在还有未确认的数据时,把之后多次写入的小数据攒在一起,等到已发出的数据全部得到确认,或者攒够一个完整的报文段再发送;
- 超过最大报文段长度(Maximum Segment Size, MSS)的消息会被分成多个报文段,可能分多次读到。
关闭 Nagle 算法(TCP_NODELAY)只改变发送的时机,接收方读得慢时,缓冲区中的多条消息仍会被一次读走,所以不能代替应用层的分帧。
关闭 Nagle 算法(TCP_NODELAY)只改变发送的时机,接收方读得慢时,缓冲区中的多条消息仍会被一次读走,所以不能代替下面在应用层约定消息边界的做法。
UDP 面向报文,一次读取得到的就是对方一次发送的一个数据报,不存在粘包。需要注意的是,接收缓冲区比数据报小时,多出的部分会被丢弃,不会留到下一次读取。
UDP 面向报文,一次读取得到的就是对方一次发送的一个数据报,不存在粘包。需要注意的是,读取时传入的缓冲区比数据报小时,数据报多出的部分会被丢弃,不会留到下一次读取。
解决方法是在应用层约定消息的边界,常用以下三种:
@@ -389,19 +390,19 @@ static String receive(DataInputStream in) throws IOException {
- 确认和重传:接收方回复确认,发送方超时没有收到确认就重传,超时时间根据测得的 RTT 计算;
- 流量控制和拥塞控制:限制已发送但未确认的数据量,避免压垮接收方和网络。
与直接使用 TCP 相比,好处在于可以按需取舍:只对需要的消息重传,不相关的消息互不阻塞,重传和拥塞控制的参数也可以按业务调整。
与直接使用 TCP 相比,好处在于可以按需取舍:只对需要的消息重传,不相关的消息互不阻塞(TCP 的情况见[选择 TCP 还是 UDP](#选择-tcp-还是-udp)),重传和拥塞控制的参数也可以按业务调整。
HTTP/3 使用的 QUIC 就是在 UDP 上实现的可靠传输,并改进了 TCP 的几处设计:
- 包号只增不减,丢失的数据放进一个新编号的包中重传。收到确认时能分清确认的是哪一次发送,RTT 测得更准;TCP 重传时沿用原来的序号,无法区分;
- 数据按流(Stream)组织,每个流按帧中的偏移量单独排序,一个包丢失时,只有包中带有数据的流会因缺数据而暂停交付;
- 一个确认帧可以携带很多个已收到的区间,TCP 的选择确认(SACK)受首部长度限制,通常最多携带 3 个区间。
- 包号只增不减,丢失的数据放进一个新编号的包中重传。收到确认时能分清确认的是哪一次发送,RTT 测得更准;TCP 重传时沿用原来的序号,只看序号无法区分,要靠时间戳选项(见[超时重传时间](#超时重传时间));
- 数据按流(Stream)组织,包中的 STREAM 帧写明所属的流和在流中的偏移量,每个流据此单独排序,一个包丢失时,只有包中带有数据的流会因缺数据而暂停交付;
- 一个确认帧可以携带很多个已收到的区间,TCP 的选择确认(SACK)放在首部的选项中,选项最多 40 字节,每个区间占 8 字节,与时间戳选项同时使用时最多携带 3 个区间。
QUIC 选择在 UDP 上重新实现,而不是改进 TCP,是因为 TCP 实现在操作系统内核中,改动要等操作系统升级才能普及;防火墙、NAT 等中间设备还会检查甚至改写 TCP 首部,不认识的新选项可能被丢弃。QUIC 运行在用户态,随浏览器和 App 一起更新,并且加密了大部分首部,中间设备无法干预。QUIC 的握手和连接迁移见 [HTTP/3](HTTP.md#http3)。
## 附录:实测
以下实验都在 Docker Desktop(Apple M1 Pro)中的 Ubuntu 24.04 容器里进行,内核为 6.10.14-linuxkit,客户端和服务器都在 127.0.0.1 上,用 iptables 丢弃指定的报文,用 tc netem 模拟时延和丢包,tcpdump 的时间换算为相对第一个报文的秒数。容器中的默认参数:
除 A9 外,以下实验都在 Docker Desktop(Apple M1 Pro)中的 Ubuntu 24.04 容器里进行,内核为 6.10.14-linuxkit,客户端和服务器都在 127.0.0.1 上,用 iptables 丢弃指定的报文,用 tc netem 模拟时延和丢包,tcpdump 的时间换算为相对第一个报文的秒数。容器中的默认参数:
```text
net.ipv4.tcp_syn_retries = 6
@@ -531,7 +532,7 @@ client: ConnectionResetError(104, 'Connection reset by peer')
### A4 最后的 ACK 丢失
连接建立后丢弃客户端发往 9000 端口的纯 ACK,客户端主动关闭,服务器读到 EOF 后立即关闭,3.5 秒后删除规则。ss -tano 的 timer 一列显示 TIME_WAIT 剩余的时间:
连接建立后丢弃客户端发往 9000 端口的纯 ACK,客户端主动关闭,服务器读到 EOF 后立即关闭,3.5 秒后删除规则。ss -tano 的 timer 一列显示定时器剩余的时间,1.254ms 是 ss 的写法,表示 1.254 秒:
```text
0.002 127.0.0.1.50966 > 127.0.0.1.9000: Flags [F.], seq 1, ack 1
@@ -539,7 +540,7 @@ client: ConnectionResetError(104, 'Connection reset by peer')
0.002 127.0.0.1.50966 > 127.0.0.1.9000: Flags [.], ack 2 被丢弃
0.210 127.0.0.1.9000 > 127.0.0.1.50966: Flags [F.], seq 1, ack 2 服务器重传 FIN
0.210 127.0.0.1.50966 > 127.0.0.1.9000: Flags [.], ack 2 被丢弃
0.418 ... 0.826 ... 1.650 ... 3.314 重传间隔翻倍
0.418 ... 0.826 ... 1.650 ... 3.314 前两次间隔约 0.208 秒,此后逐次翻倍
6.578 127.0.0.1.9000 > 127.0.0.1.50966: Flags [F.], seq 1, ack 2
6.578 127.0.0.1.50966 > 127.0.0.1.9000: Flags [.], ack 2 规则已删除,到达
@@ -617,7 +618,7 @@ tcpdump 中的区间左闭右开,{2001:3001} 即 2001~3000。容器中 net.i
### A7 零窗口与窗口探测
为了让 tcpdump 显示的窗口值就是字节数,启动容器时关闭窗口扩大选项(docker run --sysctl net.ipv4.tcp_window_scaling=0)。服务器在 listen 之前把接收缓冲区设为 16 KB,accept 之后 3 秒不读取;客户端把发送缓冲区设为 16 KB,以非阻塞方式循环写入 1 秒:
为了让 tcpdump 显示的窗口值就是字节数,启动容器时关闭窗口扩大选项(docker run --sysctl net.ipv4.tcp_window_scaling=0),回环网卡的 MTU 与 A6 一样设为 1500。服务器在 listen 之前把接收缓冲区设为 16 KB(Linux 把设置值加倍,用来容纳内核的管理开销,所以窗口关闭前收下了 29688 字节),accept 之后 3 秒不读取;客户端把发送缓冲区设为 16 KB,以非阻塞方式循环写入 1 秒:
```python
srv.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 16384)
@@ -647,7 +648,7 @@ while True:
3.002 9000 > 39616: Flags [.], ack 29689, win 15928, length 0 服务器开始读取,客户端随即继续发送
```
连续运行 3 次,窗口变为 0 的时间为 0.124~0.127 秒,3 次探测的时间分别为 0.34、0.77~0.79、1.65~1.69 秒,间隔约 0.2、0.4、0.9 秒。
连续运行 3 次,窗口变为 0 的时间为 0.124~0.127 秒,3 次探测的时间分别为 0.34、0.77~0.79、1.65~1.69 秒,间隔约 0.2、0.4、0.9 秒。3 次运行中第 2 次探测都没有收到回复:Linux 的零窗口探测不带数据,序号为最近收到的累积确认号减 1(本例为 29688),落在接收窗口之外,接收方对这类报文的确认默认至少间隔 500 ms(net.ipv4.tcp_invalid_ratelimit),第 2 次探测距上一次回复只有约 0.43 秒。
### A8 全连接队列已满
@@ -683,6 +684,58 @@ net.ipv4.tcp_syncookies = 1
连续运行 3 次,结果相同:3 个连接建立(服务器和客户端两端共 6 行 ESTAB),3 个停在 SYN-SENT。队列中的连接数比 backlog 多 1 个,是 Linux 判断队列已满时用的是“大于”。
### A9 粘包与拆包
JDK 21.0.13,macOS(Apple M1 Pro)的回环地址,不在上面的容器中运行。客户端依次写入 hello、world 和 200000 字节,服务器等待 200 ms 后读取:
```java
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
public class StickyDemo {
public static void main(String[] args) throws Exception {
try (ServerSocket server = new ServerSocket(9000)) {
Thread client = new Thread(() -> {
try (Socket s = new Socket("127.0.0.1", 9000)) {
OutputStream out = s.getOutputStream();
out.write("hello".getBytes()); // 第 1 条消息
out.write("world".getBytes()); // 第 2 条消息
out.write(new byte[200_000]); // 第 3 条消息:200000 字节
s.shutdownOutput();
s.getInputStream().read();
} catch (IOException e) { throw new UncheckedIOException(e); }
});
client.start();
try (Socket conn = server.accept()) {
Thread.sleep(200); // 让数据先在接收缓冲区里堆积
InputStream in = conn.getInputStream();
byte[] buf = new byte[1024];
int n = in.read(buf);
System.out.println("第 1 次 read:" + n + " 字节,前 10 字节 " + new String(buf, 0, 10, StandardCharsets.US_ASCII));
byte[] big = new byte[300_000];
int total = 0, r, reads = 0;
while ((r = in.read(big)) > 0) { total += r; reads++; if (reads <= 3) System.out.println("read " + r); }
System.out.println("剩余 " + total + " 字节,分 " + reads + " 次读完");
conn.getOutputStream().write(1);
}
client.join();
}
}
}
```
连续运行 3 次,输出相同:
```text
第 1 次 read:1024 字节,前 10 字节 helloworld
read 131072
read 67914
剩余 198986 字节,分 2 次读完
```
第 1 次读取把前两条消息和第 3 条消息的开头一起读出,是粘包;第 3 条消息分 3 次才读完,是拆包。第 2 次读取只得到 131072 字节,是因为 JDK 21 的 NioSocketImpl 单次 read 最多读 128 KB,与 TCP 无关。
## 参考资料
- 谢希仁. 计算机网络(第 7 版)[M]. 电子工业出版社, 2017.