如果说 UDP 是一把轻巧的快刀,那 TCP 就是一台精密的重型机械。在上篇中,我们理清了底层报文流转与 UDP 的特性;在本篇,我们将向最硬核的 TCP 协议发起总攻。
本文将带你穿透 TCP 的底层逻辑:详解首部结构、拆解三次握手与四次挥手的异常场景、剖析确认应答与超时重传的保底机制,并揭秘滑动窗口与拥塞控制背后的"降速与提速"博弈。
四、TCP 协议基础
4.1 TCP 的定位与代价
TCP 全称为"传输控制协议"(Transmission Control Protocol)。人如其名,它要对数据的传输进行详细的控制。
正因为 TCP 是面向连接且有状态的,其底层成本远高于 UDP:
- 内存成本: 内核必须为每个连接维护庞大的
struct sock结构体(状态机、哈希表、收发缓冲区)。 - **算力成本:**CPU 需要不断计算序列号、滑动窗口、超时定时器,并处理乱序重排。
- **时间与带宽成本:**需要三次握手/四次挥手,且首部至少 20 字节(UDP 仅 8 字节)。
而 UDP 无连接、无状态,内核收发包无须保存历史,封装个端口直接扔出去,轻量且极快。
4.2 TCP 报文段格式
TCP 报文段的首部字段较多,先看整体结构:
- **源/目的端口号:**表示数据是从哪个进程来、到哪个进程去。
- **32 位序号 / 32 位确认号:**后文详细讲解。
- **4 位 TCP 报头长度:**表示该 TCP 头部有多少个 32 位 bit(即有多少个 4 字节);所以 TCP 头部最大长度是 15 × 4 = 60 字节。
- **6 位标志位:**用于标识报文类型与连接状态。
任何一层协议都必须解决两个问题:如何将报头和有效载荷分离?如何交付有效载荷?TCP 协议中通过端口来指定要交付的进程;解析基础报头后,再根据偏移量(首部长度)移动指针,从而将报头与有效载荷分离。
TCP 的报头由定长报头(20 字节)+ 不定长选项组成。

图 6:TCP 报文段格式
4.3 首部长度
因为报头中的选项长度是不确定的,所以报头长度并不固定,需要首部长度字段来标识。
首部长度占 4 bit,取值范围是 0, 15,即二进制 0000~1111;其基本单位是 4 字节,也就是说首部长度的值需要乘以 4 字节,才是它所表示的报头长度,因此它能表示的范围是 0×4, 15×4 字节。由于 TCP 报头至少是 20 字节,所以 x×4 = 20,解得 x = 5,即首部长度的取值范围是 5, 15。也就是说,TCP 报文长度范围是 20, 60 字节,且只能取 4 的倍数(选项以 4 字节为单位构造),TCP 报头长度一定能整除 4 字节。
拿到一个 TCP 报文时,固定先提取 20 字节,然后解析首部长度;将首部长度 × 4 再减去 20 字节,就是还需要提取的选项大小,剩余部分就是有效载荷。
4.4 为什么 TCP 首部没有"报文长度"
我们发现,TCP 报文竟然没有"报文大小"字段,这是为什么?
每个 UDP 报文都是一个独立的数据报,就像快递包裹一样,发送方一次发送一个完整的报文,接收方也一次接收一个完整的报文。UDP 首部包含长度字段(16 位),明确告诉操作系统这个报文有多大。
而 TCP 是字节流协议,数据像水管里的水一样连续流动,没有天然的"报文"概念。TCP 首部只有首部长度,用于标识报头有多大,无法知道有效载荷大小。对端将报文接收到后,把报头一去,直接按序放到接收缓冲区里,即接收缓冲区里就只有有效载荷、没有 TCP 报头了,然后由上层自己决定如何分析有效载荷。
这也解释了为什么我们会接收到下面这样的数据:
cpp
理想情况:25\r\n{"oper":43,"x":10,"y":20}\r\n
实际:2 25\r 25\r\n{"oper":43," 25\r\n{"oper":43,"x":10,"y":20}\r\n
25\r\n{"oper":43,"x":10,"y":20}\r\n25\r\n{"oper":43,"x":10,"y":20}\r\n25\r\n{"oper":43,"x":10,
这种"有效载荷大小 + \r\n + JSON 串 + \r\n"的格式,本身就是我们上层自己定的,解析时自然也要由应用层自己分析。
4.5 16 位窗口大小
这里依旧以"客户端向服务器单向发送数据"为例,讨论可靠性保证中的一个问题:数据一次发多少合适?
如果发送端发送能力很强、接收端来不及收,数据仍无止境地向对端发送,那么对端接收缓冲区满之后,只能把这些数据丢弃(也就不会做应答)。虽然有 TCP 可靠性保障,数据被丢弃后确实可以重新发送、重传,但这么做显然太不合理了:TCP 本身就是对可靠性做保证的,如果接收缓冲区一直满,数据就一直被丢弃,那就一直做无用功,还白白浪费电力、算力、网络资源,是资源浪费、效率低下的体现。
反过来,如果发的数据太少,效率又太低。
所以我们要保证:发送端发消息时,如果知道接收端接受能力较弱,就应该降低发送速度,甚至暂停发送。
因此,在发数据时,可以在报头中把自己接收缓冲区的剩余大小带上(这个值反映了接收端的接受能力),这样对端就知道该给你发多少数据合适了。这就是 16 位窗口大小的作用。
注意 1: 以上"按照对方接受能力动态调整发送速度"的机制被称为流量控制(具体细节后文讲解)。除此之外,数据发送的量还要结合当前网络状况来决定,即拥塞控制,后文也会详细讲解。
**注意 2:**这不是单纯的"发得快还是慢"的问题。发得快并不是好事,快了就慢一点,空闲了也可以快一点,关键是要合理,主要解决效率问题。
4.6 TCP 首部源码与位段
TCP 也是一个结构体:
cpp
struct tcphdr {
__u16 source; // 16位源端口号 (Source Port)
__u16 dest; // 16位目的端口号 (Destination Port)
__u32 seq; // 32位序列号 (Sequence Number):用于数据排序和去重
__u32 ack_seq; // 32位确认序号 (Acknowledgment Number):期望收到的下一个字节的序号
#if defined(__LITTLE_ENDIAN_BITFIELD)
// 小端模式(如常见的 x86 架构)下的位域定义
__u16 res1:4, // 4位保留位(目前必须置0)
doff:4, // 4位首部长度 (Data Offset):指明TCP首部有多少个32位字(4字节)。最少为5(即20字节)
fin:1, // FIN (Finish):释放连接标志位。为1时表示发送方数据已发完,请求断开连接
syn:1, // SYN (Synchronize):同步标志位。为1时表示这是一个连接请求或接受请求(三次握手核心)
rst:1, // RST (Reset):重置标志位。为1时表示发生严重错误,必须释放连接并重新建立
psh:1, // PSH (Push):推送标志位。为1时指示接收方应尽快将数据交给应用层,而不是留在缓冲区
ack:1, // ACK (Acknowledgment):确认标志位。为1时表示 ack_seq 字段有效。连接建立后,所有报文该位都必须为1
urg:1, // URG (Urgent):紧急指针标志位。为1时表示 urg_ptr 字段有效,数据需优先处理
res2:2; // 2位保留位
#elif defined(__BIG_ENDIAN_BITFIELD)
// 大端模式(如某些网络设备或 PowerPC 架构)下的位域定义(顺序刚好反过来)
__u16 doff:4,
res1:4,
res2:2,
urg:1,
ack:1,
psh:1,
rst:1,
syn:1,
fin:1;
#else
#error "Adjust your <asm/byteorder.h> defines"
#endif
__u16 window; // 16位窗口大小 (Window Size):用于流量控制,告诉对方"我现在的接收缓冲区还能装多少字节",防止发送方发太快把我撑死
__u16 check; // 16位校验和 (Checksum):校验整个 TCP 报文段(首部+数据)
__u16 urg_ptr; // 16位紧急指针 (Urgent Pointer):当 URG=1 时有效,指出本报文段中紧急数据的字节数
};
在拆解 TCP 首部源码时,我们看到里面充斥着 fin:1、doff:4 这样的语法。这就是 C 语言中的位段。
所谓的标志位,就是一个一个比特位;设置标志位就是置 1,反之置 0。
位段可以让我们按"比特"来分配内存。TCP 协议极其"抠门",为了节省带宽,它要求 6 个标志位(SYN、ACK、FIN 等)各自只能占 1 个比特,4 个比特合在一起才等于半个字节。
但也正因为位段是直接干预内存最底层的比特位,不同 CPU 架构(大小端)对位段的读取顺序是相反的 。这就是为什么源码里会看到 #if __LITTLE_ENDIAN_BITFIELD 这样看似奇怪的代码:Linux 内核为了兼容不同的 CPU,不得不写两套长得完全相反的位段定义,以此保证数据发到网络上时,全球所有机器的解析结果都一致。
4.7 为什么需要标志位
TCP 报文会存在不同的类型,自然需要不同的处理方法。
比如 TCP 通信前要先建立连接,就要发起建立连接报文(如三次握手,后文详细讨论),此时报文并不是以传输数据为目的;未来结束通信时,也会有断开连接的请求。也就是说,虽然都是 TCP 报文,但消息类别不一样。
而且客户端一般是多个,作为接收端的服务器来看,收到的 TCP 报文就一定会存在不同的类型,针对不同的类型就要有不同的做法。
所以传输的 TCP 报头中,就必须有表示 TCP 报头类型的字段。那么各标志位分别是什么意思呢?先总览一遍各字段的含义。
4.8 六个标志位速查表
| 标志位缩写 | 全称 | 中文名称 | 核心含义与作用 | 典型使用场景 |
|---|---|---|---|---|
| URG | Urgent | 紧急指针 | **紧急指针是否有效。**为 1 时,表示报文中有紧急数据,应优先处理,此时 16 位紧急指针(urg_ptr)才生效。 | 极少使用(如 Telnet 中断指令)。 |
| ACK | Acknowledgment | 确认 | **确认号是否有效。**为 1 时,TCP 首部中的 32 位确认序号(ack_seq)才合法。 | 连接建立后,所有传输的报文段该位都必须为 1。 |
| PSH | Push | 推送 | **提示接收端立刻读走数据。**为 1 时,接收方 TCP 会立刻将数据交给应用层,而不必等接收缓冲区填满。 | 交互式通信(如 SSH、输入命令后立刻响应)。 |
| RST | Reset | 重置 | **要求重新建立连接。**为 1 时,表示发生严重错误或拒绝连接,强制断开(复位报文段)。 | 访问未开放的端口、异常断开连接时。 |
| SYN | Synchronize | 同步 | **请求建立连接。**携带此标志位的报文称为"同步报文段",用于同步初始序号。 | 三次握手(第 1 次和第 2 次)。 |
| FIN | Finish | 结束 | **请求释放连接。**为 1 时,表示发送方数据已发送完毕,请求断开连接。 | 四次挥手(主动关闭方发出)。 |
4.9 ACK:确认标志位
ACK 指明了该报文就是一个应答报文,该标志位指明确认信号是否有效。一般将 ACK 常设为 1(通常都是应答报文,或者"数据 + 应答"报文)。其他情况,如第一次握手时,ACK 置为 0。
4.10 PSH:推送标志位
如果接收端上层业务繁忙,可能无法及时把接收缓冲区里的数据读取给上层,那么缓冲区就会积压大量数据,进而越来越满。如果已经没空间了,发送端就不能再发数据了,而发送端不能干等着。
一种方式是:当接收端读取了一部分数据时,主动向对端发送一个同步请求,提示发送端已经有空间了。
另一种方式是:发送端主动定期发送窗口探测报文,接收端在应答 TCP 报文时就可以对缓冲区空间进行同步。
今天发送一个标志位为 PSH 的 TCP 报文,就是在催促对方尽快将数据递交给上层;但不一定非要缓冲区满了才发 PSH------如果当下就是要处理一个比较紧急的信息,也可以带上 PSH。
那么这里就有一个问题:什么叫"要尽快将数据递交给上层"?我们上层应用程序不是自己读取吗,OS 能起到什么作用?比如这个程序 accept 之后就是不读不写,那么发送 PSH 给 OS,OS 催促程序读数据,可程序连读取功能都没有,怎么催?
其实,我们的读取逻辑并不是只有当缓冲区为空时才会阻塞,有时候即便缓冲区里面有数据也会阻塞,因为接收缓冲区存在低水位线和高水位线的问题。比如只有当缓冲区数据超过若干个字节以上,才让 read 系统调用的条件就绪(后面谈到事件 I/O 就绪时会讲解)。
所以 PSH 的本质就是将系统调用的条件置为就绪,这样上层调用 read 才会读到数据。
那么回到之前的问题:如果程序就是不读数据,连 read 都没有呢?其实,一款服务器的宗旨就是读取数据,不读那就是 bug,与 OS 无关。
4.11 URG:紧急指针标志位
URG 一般不太常用,配合 16 位紧急指针使用。
**它标识紧急指针是否有效。**为 1 时,表示报文中有紧急数据,应优先处理,此时 16 位紧急指针(urg_ptr)才生效。
下面举一个例子。
TCP 是保证可靠性的,TCP 报文内部包含序号,报文按序到达;报文到达就是一个入缓冲区的过程,来一个数据就放到末尾,读数据就取头部。所以我们可以将接收缓冲区当作一个字节流式的接收队列。
但这个优点也会带来缺点:如果我们有数据想被优先处理,这个时候就做不到了。于是我们引入了紧急指针。注意,这是一种特殊情况,不是主流,大部分数据都是正常的。
举个实际应用例子:我们打开网盘网页,想向网盘传输数据时,会发送大量报文。如果上传过程中发现上传的数据错了、要取消上传,那么"取消上传"也是一个报文。如果按常规方式处理,它会被放到网盘服务器接收缓冲区的尾端,那么必须把前面的数据都处理完才能真正停止,但这些数据已经没有意义了。所以,当 OS 接收到一个紧急报文时,就会优先处理这个报文,将其读取到上层,上层就可以根据数据决定是停止还是继续。所以,紧急数据的本质就是递交给上层时进行插队。
注意,紧急数据并不属于常规数据,一般把这种数据也称为带外(OOB,out-of-band)数据。
那么紧急指针又是什么呢?
紧急指针标示的是紧急数据相对于当前报文序列号(Seq)的偏移量 。当 URG=1 时,接收方通过 Seq + urg_ptr 就能计算出紧急数据的结束位置。
那么有几个紧急数据呢?其实,由于紧急数据不是主流,它只有一个字节,而这一个字节往往可以用来设置状态码。
它的存在是为了解决"带外数据(OOB)"的实时性问题。比如我们熟知的 Ctrl+C 中断指令,如果老老实实跟着文件数据排队,可能要等好几秒才生效。加上 URG 标志和紧急指针后,操作系统就可以直接"截胡",把这个指令优先交给应用层处理,实现"加塞"的效果。不过,现代操作系统的实现通常将其简化为只针对 1 个字节的带外数据,平时在 HTTP 等高并发场景中极少用到,但作为 TCP 设计精巧性的一环,非常值得了解。
五、TCP 连接管理
在正常情况下,TCP 要经过三次握手建立连接,四次挥手断开连接。上图中的 SYN_SENT、SYN_RCVD、ESTABLISHED 等状态字段,都是内核层面的整数,也就是宏定义的值。
未来的连接会非常多:客户端与服务端要通信就要建立连接,而客户端数量庞大,于是我们必须对连接进行管理。有的连接处于 SYN_SENT,有的处于 ESTABLISHED......操作系统管理连接的方法同样是"先描述,再组织",对应到内核中就一定会有结构体(如 struct sock、TCP 的 struct tcp_sock),所以结构体里面就有状态属性。
5.1 SYN 与三次握手

图 7:TCP 三次握手建立连接
在 TCP 中,数据绝不是像 UDP 那样上来就简单粗暴地直接发送,而是必须先建立连接。建立连接的本质是"建立共识":双方需要确认彼此是否具备收发数据的能力,以及是否同意进行通信。
这个过程就是我们熟知的三次握手 :客户端发送 SYN 报文(请求建立)→ 服务端回复 SYN+ACK 报文(同意并确认)→ 客户端回复 ACK 报文(确认)。在此期间,前两次握手是不携带任何业务数据的(只有 TCP 报头,并在标志位上置 1 表明意图),因为通信尚未真正建立(这有效防止了 SYN Flood 攻击)。但有一个细节:第三次握手的 ACK 报文是可以携带业务数据的,因为此时客户端已确认了服务端的收发能力,捎带数据能提高效率。只有三次握手成功后,双方在逻辑上才具备了稳定的收发能力。
这也解释了一个问题:发送第一批数据时,发送方怎么知道对方的缓冲区大小呢?因为此时已经不再是第一次发报文了,在三次握手交换报头的过程中,双方已经通过 TCP 首部的"窗口(Window)"字段协商过了对方的接收能力。
5.2 为什么要进行三次握手
**原因一:**可以获取对端的接收能力(通过 16 位窗口大小)。
**原因二:**以最短的方式进行全双工验证。以 A 端向 B 端发起连接请求为例:第一次握手能确定 A 是否能发;第二次握手能确定 B 是否能收、是否能发;第三次握手能确定 A 是否能收。本质上是验证网络是否流畅、能否支持全双工。
三次握手的本质,就是双方建立共识、确认彼此通信能力的过程。
注意 1: 三次握手交换的是报头,前两次未携带数据;经过前两次确认后,第三次握手其实可以携带数据。对发送端来说,流程是"发 SYN → 收到 SYN+ACK → 发 ACK",发出 ACK 时就已三次握手建立成功;而对端收到 ACK 就说明建立成功,同时如果发现 ACK 中带有数据,顺手解析即可。
注意 2: connect 不参与三次握手,它只是发起连接,三次握手的全过程由 client/server 的操作系统内核自动完成。
**注意 3:**长连接通过复用已建立的 TCP 连接,减少重复握手和断开的开销,从而显著提升性能。
5.3 三次握手是"合并"后的四次握手
既然是全双工通信,建立连接理应双向确认,那不应该需要四次握手吗?
实际上,如果完全分开:客户端发 SYN(请求)→ 服务端回 ACK(确认)→ 服务端发 SYN(请求)→ 客户端回 ACK(确认),确实是四次。
但 TCP 的设计极其巧妙:服务端在收到 SYN 时,因为报文首部有标志位,它顺手把"我收到了(ACK)"和"我也要建连(SYN)"合并成了一个 SYN+ACK 包发回去。这正是网络通信中经典的**"捎带确认"**机制。把四次握手压缩成了三次,既保证了全双工的双向确认,又极大地节省了网络带宽和延迟。
5.4 第三次握手为何可以携带数据
在 TCP 的三次握手中,前两次(SYN、SYN+ACK)是绝对不允许携带数据的。这主要是为了防止 SYN Flood 攻击,避免服务器在确认对方身份前盲目分配宝贵的内存资源。
但是,第三次握手的 ACK 报文是可以携带数据的! 因为此时客户端已经收到了服务端的 SYN+ACK,确认了服务端的收发能力完全正常,且服务端也已经为这个连接分配好了资源。
站在发送端 的视角:发出 SYN → 收到 SYN+ACK → 发出带有数据的 ACK。在发 ACK 的那一刻,发送端底层就已经进入了 ESTABLISHED 状态,认为建立成功。
站在接收端 的视角:收到这个 ACK,底层同样立刻进入 ESTABLISHED 状态,同时发现报文后面跟了数据,于是内核顺手把数据剥离下来,丢进内核接收缓冲区。
为了极致地提高传输效率,客户端直接把第一批业务数据"捎带"在这个 ACK 包里发过去,省去了单独发一个数据包的开销。
5.5 握手失败与 RST

图 8:三次握手中的状态错位与 RST 报文
TCP 建立连接并不总是一帆风顺,连接随时可能因网络波动而断开。要理解连接为何失败,我们需要站在请求端(客户端) 和**接受端(服务端)**各自的立场来看待状态机的流转。
- 各自为战的"时间差"(对应左图)
三次握手的过程中,请求端在发出第三次 ACK 时,就单方面认为连接已经 ESTABLISHED(建立成功),可以发数据了;而接受端必须真正收到这个 ACK,才认为连接建立成功。因为双方都是站在自己的立场看问题,所以两端认为"连接建好"是存在短暂时间差的。
- 前两次握手为何不怕丢包?(对应中图)
在三次握手中,前两次报文丢失其实并不可怕,因为它们都有后续的"隐含应答":第一次 SYN 丢了,有第二次 SYN+ACK 兜底;第二次 SYN+ACK 丢了,有第三次 ACK 兜底。
唯独第三次 ACK 是真正的"命门" 。因为这个 ACK 发出去之后,没有任何后续报文来确认它。一旦它在半路丢了,请求端会认为自己建好了,但接受端却一直卡在 SYN_RCVD 状态,认为没建好。
- 状态错位与 RST 的绝杀(对应右图)
当双方状态不一致时,灾难就发生了:请求端的 ACK 丢了,但它自己不知道,紧接着就把业务数据发了过去。接受端此时还在纳闷:"我们连接还没建好呢,你怎么就发数据了?"于是,接受端会直接回复一个**RST(Reset 重置报文段)**,强行打断这个非法的连接。
- 浏览器里的"连接已重置"
这也就是为什么我们在使用浏览器时,偶尔会看到**"连接已重置(Connection Reset)"**的报错。这通常意味着你的握手或者数据传输过程出现了严重异常,对端直接"掀桌子"了。
需要注意的是,在 TCP 通信中,双方地位是对等的 。不仅是握手失败会发 RST,在通信过程中的任何时刻(比如发现端口未开放、连接超时、或者发生了严重错误),任何一方都可以随时发送 RST 报文来强制断开连接。这就像 TCP 协议里的一把"紧急刹车",不需要等对方同意,直接强制重置。
5.6 FIN 与四次挥手

图 9:TCP 三次握手与四次挥手
同理,断开连接(FIN)也必须征得双方同意 。因为 TCP 是全双工的,一方先发起 FIN 请求,另一端必须回 ACK 应答,这代表单向的断开请求成功;随后另一端也要发起自己的 FIN 请求,对端再次回复 ACK 后,连接才算正式被完整关闭(即四次挥手)。
在 TCP 协议中,当一端想要结束通信时,会采用四次挥手(FIN-ACK 机制)来终止连接,而非直接强制断开,这是为了保证数据的可靠性和网络的健壮性。如下表所示:
| 挥手阶段 | 主动关闭方状态 | 被动关闭方状态 | 内核行为与关键动作 |
|---|---|---|---|
| 第一次挥手 | FIN_WAIT_1 | ESTABLISHED | 主动方发送 FIN,进入等待确认状态。 |
| 第二次挥手 | FIN_WAIT_2 | CLOSE_WAIT | 被动方收到 FIN,回复 ACK,进入等待应用层调用 close() 的状态。 |
| 第三次挥手 | TIME_WAIT | LAST_ACK | 被动方发送 FIN,进入等待最终确认状态;主动方收到 FIN 后回复 ACK,进入 TIME_WAIT。 |
| 第四次挥手 | -(连接关闭) | -(连接关闭) | 被动方收到 ACK,连接彻底关闭。 |
断开连接的本质,也是建立双方"可以断开连接"的共识。
如下,C 为主动关闭方,C 与 S 的挥手对话为:
- C→S:FIN------我(C)要发的数据已经发完了,我(C)要和你(S)断开连接。
- S→C:ACK------好的收到。我(S)正在给你发着数据呢(假设有),等一会儿。
- S→C:FIN------我(S)好了,可以断开连接了。(如果我等待 MSL 后收不到 C 的 ACK 回应,那就当作丢包了,重发。)
- C→S:ACK------OK,我(C)收到了。(如果等待 2MSL 后 S 没有给我重发,那么它就是收到 ACK 回应了,可以断开连接了。)
注:MSL 是一个时间信息,默认为 60 秒。
5.7 握手能合并,挥手为何不能
建立连接时(三次握手): 客户端和服务器都处于 CLOSED 空闲状态,双方都迫不及待地想要建立连接来发数据。所以,服务端收到 SYN 后,把"确认收到(ACK)"和"请求建连(SYN)"合并成一个包发回去,顺理成章。

图 10:三次握手的合并与四次挥手的独立确认
很多人在背诵四次挥手时,不理解为什么不能像三次握手那样"三步走"。其实,只要明白 TCP 是全双工 的,一切就迎刃而解了:四次挥手,本质上是独立关闭两条方向相反的信道。前两次挥手,关闭的是"主动关闭方到被动关闭方"的发送信道;后两次挥手,关闭的是反方向的信道。
假设客户端先发起断开,前两次挥手成功后,会进入一个极其重要的**"半关闭(Half-Close)状态"** 。此时,客户端确实不能再给服务端发消息了,但服务端依然可以给客户端发消息!
比如在经典的"下载大文件"场景中,客户端发完请求后就会发出 FIN,表示"我不发了";但服务端还要继续把庞大的文件数据推给客户端。只有在服务端也把数据彻底发完之后,它才会发出自己的 FIN。这就是为什么断开连接必须经历四次挥手------因为"我不想发了"和"你不想发了",往往是不同步的。
断开连接时(四次挥手): 情况完全不同。假设客户端正在下载一个大文件,突然觉得不想下载了,发送了一个 FIN 表示"我要断开"。此时,服务端的文件可能才传了一半,数据还在源源不断地发呢! 服务端不能立刻丢掉手头的工作去发 FIN,它只能先回复一个 ACK(意思是:"我知道你想断了"),然后继续把剩余的数据发完。直到所有数据都传输完毕,服务端才会发送自己的 FIN,表示"我也发完了,可以挂了"。
所以,**握手能合并是因为双方都没事干,挥手不能合并是因为对方可能还在忙,也就是双方想断开连接的时间不一致。**不能很好地使用捎带应答,这就是为什么断开连接必须经历两次独立的确认,也就是经典的"四次挥手"。
5.8 半关闭、close 与 shutdown
客户端退出或关闭、服务器不关闭(不进行 close)时,此时连接就是半关闭状态。即在逻辑上,服务器还可以向客户端发消息,但客户端的文件描述符已经关闭了。
在用户态,调用 close(fd) 确实让这个描述符失效了,应用层再也无法通过它收发数据。但在内核态,TCP 协议栈才刚刚开始四次挥手。
内核会在后台帮你发送 FIN、接收 ACK,甚至如果对端还在发数据,内核还会默默帮你收下并存入接收缓冲区(只是应用层没有 fd 去读了)。直到双方彻底交换完 FIN,连接才会真正在底层销毁。
这也是为什么我们需要 shutdown(fd, SHUT_WR) 这个函数。它还有 SHUT_RD、SHUT_RDWR 等选项。因为 close 是"连读带写全关",而 shutdown 允许我们只关闭发送通道(不再发数据),但保留接收通道。它仅仅是改变了底层 TCP 连接的"半关闭状态",并没有回收这个 fd 数字。这正是 TCP 全双工特性的应用层体现:关闭,也可以分步进行。
当我们调用 shutdown(fd, SHUT_WR) 时,本质上是在做一次"半关闭"。
- 此时调用
write: 会直接报错。底层不仅会返回-1,还会抛出一个SIGPIPE信号。如果应用层没忽略这个信号,整个进程会直接崩溃。这也是为什么服务器代码通常要在一开始就写上signal(SIGPIPE, SIG_IGN)。 - 此时调用
read: 依然可以完美运行。因为读通道并没有关,我们依然可以从内核缓冲区里把对方发来的数据读出来。直到对方也发来FIN,read才会返回0(EOF),宣告连接的彻底终结。
如果客户端已经关闭了,服务端不关闭,那么服务端就会处于 CLOSE_WAIT 状态,依旧占用文件 fd,服务端到客户端的连接也没有释放,就会有文件描述符泄漏问题!一直这样会导致可用的文件描述符越来越少,服务器会变得越来越卡,甚至崩溃。
5.9 理解 TIME_WAIT 状态

图 11:TIME_WAIT 状态
对于主动断开端:第一次发 FIN,第二次收 ACK,第三次收 FIN,第四次发 ACK。那么,为什么主动断开的一方发完最后一个 ACK 后不能立即关闭,而是要进入 TIME_WAIT 状态等一段时间?当前的四次挥手工作不是已经做完了吗?必须要等待一段时间的话,要等待多长时间?这个状态的意义是什么?
主要有两个原因:
- 确保对端收到 ACK。 如果等待的这段时间内对端接收不到
ACK,就会超时重传FIN;收到重传的FIN,就说明对端没有收到ACK,需要给对端重传ACK。 - **确保下次通信不受本次陈旧报文影响。**等待的这段时间,让网络中两个方向上的陈旧报文消散(即把传输过来的陈旧报文丢弃),防止陈旧报文对下次连接建立产生干扰。
为什么等待的时间是 2MSL?
MSL 是 TCP 报文的最大生存时间,因此 TIME_WAIT 持续存在 2MSL 的话:
- 就能保证在两个传输方向上的尚未被接收或迟到的报文段(可能在某个路由器网关卡着)都已经消失(否则服务器立刻重启,可能会收到来自上一个进程的迟到的数据,但是这种数据很可能是错误的);
- 同时也是在理论上保证最后一个报文可靠到达(假设最后一个
ACK丢失,那么服务器会再重发一个FIN。这时虽然客户端的进程不在了,但是 TCP 连接还在,仍然可以重发LAST_ACK)。
5.10 端口被占用与 SO_REUSEADDR
为什么服务器重启会提示"端口被占用"?
我们发现,刚把服务器关掉(Ctrl+C),想立刻重新启动,结果 bind 直接报错(Address already in use)。

图 12:服务器重启时端口被占用
其实,这就是 TIME_WAIT 状态导致的。
当服务器主动断开连接时,它并不会立刻释放端口,而是会进入 TIME_WAIT 状态并停留 2MSL 的时间。这么做的核心目的,是为了确保最后一个 ACK 包能稳稳地到达对端 ,并防止网络中延迟的旧数据包干扰下一次建立的新连接。
在此期间,端口被内核占着,新的 bind 请求自然会被拒绝。为了解决这个问题,我们在服务端代码里可以考虑开启一个选项------SO_REUSEADDR。
使用 setsockopt() 设置 socket 描述符的选项 SO_REUSEADDR 为 1,表示允许创建端口号相同但 IP 地址不同的多个 socket 描述符:
cpp
int opt = 1;
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
这样,操作系统就会允许我们在 TIME_WAIT 状态下直接复用这个端口,实现秒级重启,再也不用等了。
深度追问:用了 SO_REUSEADDR 秒级重启,旧数据包不会回来捣乱吗?
这是一个极好的问题。既然 OS 原本怕"陈旧包"捣乱才锁死端口,为什么加个 SO_REUSEADDR 就能强行破门?陈旧包难道不会污染新连接吗?
答案是:SO_REUSEADDR 只是帮你绕过了"端口分配"的锁,但 TCP 底层拦截脏数据的机制依然在完美运转。
- **五元组防线:**TCP 依靠五元组识别连接。就算你复用了服务端的 8080 端口,但只要客户端换了端口,旧数据包到了内核,一查五元组,发现找不到对应的连接,直接静默丢弃。
- **序列号防线:**哪怕客户端极其巧合地用了一模一样的端口,新连接建立时,双方也会重新生成随机且不同的初始序列号(ISN)。旧包里的 Seq 号对不上号,内核协议栈会无情地把它扔掉。
所以,SO_REUSEADDR 是让程序员在确保安全的前提下(比如常见的服务端重启场景)拿回端口控制权,它完美兼顾了"开发便利"与"底层安全"。
**注意 1:**客户端再次连接服务器时会更换端口,因此不会受到陈旧报文影响(历史报文的源端口和目的端口与新的端口对不上,会被主动丢弃)。
注意 2: 因为 TIME_WAIT 状态的存在,服务器退出后不能立即重启(更换端口可以立即重启,但不推荐;或者做一些选项设置,也可以立即重启)。
但在应用角度,比如某些商家的 App,此时有 10000 个客户端与服务器建立了连接,假设已经达到极限,再来一个客户端就成为压死骆驼的最后一根稻草,于是服务器崩溃了。对于前 10000 个客户端,服务端就是主动断开连接的一方;但由于 TIME_WAIT 存在,短时间内又无法快速重启。所以从应用角度,我们既需要 TIME_WAIT 来确保不会受到旧报文影响,又要有快速重启的能力,于是就有了 setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));。
5.11 TCP 状态转换流程

图 13:TCP 状态转化流程解析
服务端状态转化
- CLOSED → LISTEN 服务器端调用
listen后进入LISTEN状态,等待客户端连接。 - LISTEN → SYN_RCVD 一旦监听到连接请求(同步报文段),就将该连接放入内核等待队列中,并向客户端发送
SYN确认报文。 - SYN_RCVD → ESTABLISHED 服务端一旦收到客户端的确认报文,就进入
ESTABLISHED状态,可以进行读写数据了。 - ESTABLISHED → CLOSE_WAIT 当客户端主动关闭连接(调用
close),服务器会收到结束报文段,服务器返回确认报文段并进入CLOSE_WAIT。 - CLOSE_WAIT → LAST_ACK 进入
CLOSE_WAIT后说明服务器准备关闭连接(需要处理完之前的数据);当服务器真正调用close关闭连接时,会向客户端发送FIN,此时服务器进入LAST_ACK状态,等待最后一个ACK到来(这个ACK是客户端确认收到了FIN)。 - LAST_ACK → CLOSED 服务器收到了对
FIN的ACK,彻底关闭连接。
客户端状态转化
- CLOSED → SYN_SENT 客户端调用
connect,发送同步报文段。
所以connect本质就是发起三次握手,三次握手的具体过程由 client/server 的 OS 自动完成。
即使服务端不写accept,三次握手建立也会成功,这意味着accept不参与三次握手,只负责把底层建立好的连接拿到上层。 - SYN_SENT → ESTABLISHED
connect调用成功,则进入ESTABLISHED状态,开始读写数据。 - ESTABLISHED → FIN_WAIT_1 客户端主动调用
close时,向服务器发送结束报文段,同时进入FIN_WAIT_1。 - FIN_WAIT_1 → FIN_WAIT_2 客户端收到服务器对结束报文段的确认,则进入
FIN_WAIT_2,开始等待服务器的结束报文段。 - FIN_WAIT_2 → TIME_WAIT 客户端收到服务器发来的结束报文段,进入
TIME_WAIT,并发出ACK(确认服务端的FIN)。 - TIME_WAIT → CLOSED 客户端要等待一个 2MSL(Max Segment Life,报文最大生存时间)的时间,才会进入
CLOSED状态。
下图是 TCP 状态转换的一个汇总。

图 14:TCP 状态转换汇总
六、TCP 可靠性:确认应答与重传
TCP 的可靠性,核心依靠确认应答机制实现,并配合序号、确认号解决丢包与乱序问题,同时利用捎带应答提升传输效率。先看下面这张图。

图 15:TCP 确认应答机制
6.1 确认应答机制
- 发送方发送报文时,报文头部携带序号 seq。
- 接收方收到报文后,回复应答报文,其中的确认号 ack = seq + 1。
- ack 的含义是:序号 ack 之前的所有数据,我都已经收到了。
- 发送方如果超时没有收到对应的 ack,就认为报文丢失,执行重传。
- 应答由操作系统内核自动维护;应答本身不带业务数据,也不对"应答"再做应答。
收到 ack,代表这条 ack 对应的历史报文已经可靠交付;最新发出去、还没收到 ack 的报文,可靠性暂时无法保证。所以,要保证可靠性,本质上就是保证"我们关心的报文不再是那条最新的、悬而未决的报文",而是已经收到确认的历史报文。
6.2 停等协议
最基础的确认应答方式就是停等协议:发一条消息 → 停下来等对方应答 → 收到应答后再发下一条。它的逻辑简单、实现可靠,但效率很低,信道大部分时间处于空闲状态。
6.3 连续发送
客户端不必等待应答,可以连续发送多条报文(例如 seq=100、200、300),服务端再陆续返回 ack(101、201、301)。这样能充分利用网络、提升吞吐量,但也引出了两个新问题:丢包识别 与报文乱序。
6.4 序号与确认号
累积确认解决丢包
ack 是"累积确认":比如收到 ack=301,就代表 301 之前(100、200、300)的数据已经全部收到。中间的 ack(101、201)就算丢了也没关系,只要后面更大的 ack 到达,发送方就知道前面的数据已经被接收,允许部分应答丢失(这个特性后面会和滑动窗口配合使用)。
序号解决乱序
网络中不同报文走过的路径、延迟不一样,先发的报文可能后到达,这就是乱序。接收方依靠报文中的序号,对收到的数据重新排序,再向上层交付有序的数据。
6.5 捎带应答
为什么同时需要【序号 seq】和【确认号 ack】两个字段?因为 TCP 是全双工通信,两端可以同时收发数据:服务端回复 ack、确认客户端数据的同时,这个报文里也可以带上服务端自己要发给客户端的数据。
- **确认号 ack:**用来确认对方发给我的数据(完成应答)。
- **序号 seq:**用来标记我自己发给对方的数据,等待对方后续确认。
如果应答没有数据,只要把 ack 标志位置 1、不携带数据即可;如果有数据,那么就可以在 ack 置 1 的同时把数据一并携带上。
这种把应答和自身数据合并在同一个报文里的方式叫作捎带应答:既给了应答,又传输了有效载荷,减少报文数量、提升效率。将来大部分报文都是捎带应答的报文,即大部分 ack 都是置 1 的。
如果只使用一个序号,就无法同时做到"确认对方的数据"和"标记自己发送的数据",也就无法支撑全双工。
小结:TCP 确认应答的核心
- 用序号标记发送的数据,解决乱序。
- 用累积确认号 ack 告知发送方哪些数据已经收到,识别丢包、支持超时重传。
- 双序号设计支持全双工 + 捎带应答,在保证可靠的同时提升传输效率。
- 应答由内核自动维护,应答本身不需要被应答。
6.6 理解序号:TCP 面向字节流

图 16:TCP 的序号按字节编号
结合上图,我们可以彻底弄懂 TCP"面向字节流"的本质:TCP 不是给"数据包"编号,而是给每一个"字节"都编了号。
我们可以把 TCP 的发送缓冲区极其直观地想象成一个巨大的 char 类型数组。因为是连续的字节,数组的每一个下标天然就对应着一个字节的编号。当连接建立时,双方会各自随机生成一个初始序列号(ISN) 作为起点。假设初始序列号是 1,应用层要连续发送两次数据,每次 1000 字节:
- 发送第一个报文段(长度 1000),首部
Seq = 1,它覆盖字节编号1 ~ 1000。 - 接收方收到后,回复
ACK = 1001(累积确认:1~1000 我都收到了,期待 1001)。 - 发送方接着发送第二个报文段(长度 1000),首部
Seq = 1001,它覆盖字节编号1001 ~ 2000。 - 接收方再次回复
ACK = 2001。
接收方收到 Seq=1001 的报文,就能通过"累积确认"回复 ACK=2001,代表"1 到 2000 我都收到了,我期待下一个编号是 2001 的字节"。
这正是为什么 TCP 没有"粘包"的概念,却必须由应用层自己解决"粘包"。 因为在内核底层看来,数据就是一条平坦的 char 数组流,应用层发几次 write() 都没有边界。只有在应用层自己加上 \r\n 或是 Content-Length 这样的"标签",才能从这根连续的水管里,把原本属于不同业务的数据切分出来。
6.7 超时重传

图 17:TCP 超时重传的两种丢包情形
结合上图,我们深入探讨一下 TCP 的"超时重传"机制。
- 准确理解"丢包":发送端的主观判定
结合图来看,丢包通常有两种情况:一是数据报在网络中丢失 (左图);二是接收端的 ACK 应答包丢失(右图)。
对于发送端来说,只要没有收到 ACK,通信就存在不确定性。发送端无法直接透视网络,它不知道到底是数据丢了,还是对方收到了但应答丢了。因此,所谓"丢包",并不是一个客观事实,而是发送端在等待一段时间(超时)后,没有收到 ACK 而做出的"主观判定"。
- 接收端的去重(右图场景)
如果发生了情况二(只是 ACK 丢了),发送端超时后会重传刚才的数据包。此时接收端会收到两份重复的报文。
不用担心,这正是序列号 的另一个核心作用------去重 。接收端一看 Seq=1,发现这个区间(1~1000)的数据自己刚才已经收过了,就会直接把这个重复的包丢弃,并再次回复一个 ACK=1001,告诉发送端:"别发了,我早就收到了。"
- 超时时间(RTO)到底该设多长
既然要等,那等多久才判定为"丢包"呢?
- 如果设得太短:网络本来只是稍微有点延迟,发送端就急不可耐地重传,会导致网络中出现大量重复报文。
- 如果设得太长:网络确实丢包了,发送端却傻等半天,导致传输效率极低。
由于网络环境是动态变化的(有时拥堵,有时通畅),超时时间必须是动态计算的。最理想的情况是:找到一个最小的时间,刚好能保证 ACK 在这个时间内返回。
- Linux 的指数退避(Exponential Backoff)
在 Linux 等现代操作系统中,超时时间(RTO)通常以 500ms 为一个基准单位进行动态调整,并采用指数递增的策略:
- 第一次超时:等待
500ms后重传。 - 如果还没收到 ACK:等待
2 × 500ms(1 秒)后再次重传。 - 如果依然没收到:等待
4 × 500ms(2 秒)...... - 以此类推,每次重传的等待时间翻倍。
这个过程,本质上是发送端在不断**"试探"当前网络的真实延迟**。但如果重传次数累计达到一定上限(系统默认值),TCP 会认为网络或对端主机已经彻底崩溃,从而强制关闭该连接,并通知应用层(抛出异常)。
七、TCP 性能优化
7.1 滑动窗口
上文我们讨论了确认应答策略:对每一个发送的数据段都要给一个 ACK 确认应答,收到 ACK 后再发送下一个数据段。这样做有一个比较大的缺点,就是性能较差,尤其是在数据往返时间较长的时候。于是我们采用批量化、一次性发送数据的方式,并用序号解决乱序,从而提高传输效率。
那么,发送方一次要给对方发送多少数据,由什么决定?答案是------滑动窗口。

图 18:TCP 滑动窗口
滑动窗口是发送端发送缓冲区的一部分。 如果把发送缓冲区看成一个 char[N] outbuff,那么窗口就是该数组上的两个指针 int start 与 int end,窗口大小就是 end - start。
窗口大小指的是无需等待确认应答、就可以继续发送数据的最大值。
7.2 窗口的三个区域与动态调整
由于滑动窗口的存在,发送缓冲区被分成了三个部分:
- **已发送已确认(缓冲区清空):**这部分数据已经无效,空间可以重新利用;不需要刻意清空缓冲区,将来写数据时直接覆盖即可。
- **已发送但暂未收到确认(暂不用应答,可直接发送):**这部分位于窗口内,已经发出,正在等待对方的累计确认。
- **待发送部分:**位于窗口内、但还没有发送的数据。
由于序号在发送轮次中依次增大,也就意味着窗口是向右移动的。因此,滑动窗口的本质就是 start 和 end 整体增加。
那么,滑动窗口的大小由谁决定?
- 如果滑动窗口太大:就会一次性给对方发送太多数据,导致对方来不及接收。
- 如果滑动窗口太小:一次发送的数据就会比较少,传输效率随之降低。
所以,滑动窗口大小由对方的接受能力决定,也就是由对方接收缓冲区的大小(TCP 的窗口大小字段)决定。
因此,滑动窗口的本质就是流量控制的具体实现方案,可以根据对端接受能力进行限流与增流。
调整滑动窗口大小的方式是:start = 报文确认序号,end = start + win(win 即对端的接受能力)。
**注意:**滑动窗口大小并不是单由对端接收能力决定,以上的描述与计算并不严谨,但方便理解。后文讲拥塞控制时会提到这一点。
围绕窗口,还有几个常见问题:
- **滑动窗口可以向左滑吗?**不能。从概念上讲,把已经发送并确认的数据再发一次显然不合理;从算法计算上讲,窗口始终是向右移动的。
- 窗口可以变大、变小或保持不变吗? 窗口大小一直在动态变化,由网络因素(拥塞控制)和对端接收能力(流量控制)共同影响。假设对方接收缓冲区总大小为 64KB,已经积压了 50KB 数据,那么返回的
win就是 14KB;如果某一时刻对端上层一瞬间把数据全取走了,返回的win就直接变成 64KB,也就是说窗口是可以变大的。
如果对端上层一直不读取数据,那么缓冲区越来越满,返回的win就越来越小,窗口也会越来越小。
如果上层刚好读取了与对端发送数据等量的数据,那么空闲缓冲区大小不变,返回的win就不变,所以窗口也可以保持不变。 - **滑动窗口可以为 0 吗?**可以。比如缓冲区没有空间或对端接收能力为 0,即对端通告的窗口大小为 0,说明缓冲区已经满了。
- **滑动窗口会溢出吗?**不会。事实上,滑动窗口是一个环形结构。
7.3 滑动窗口中的丢包
丢包可以分成三个基本情况(第二种和第三种最终都会转化为第一种,所以我们重点看第一种)。
- 最左侧丢失
a. 最左侧报文数据丢失

图 19:最左侧报文数据丢失
如果 1001--2000 丢失,但接收端主机收到了 2001--5000 的三个报文,此时接收端应答的确认序号就是 1001。因为没收到最左侧的报文,而滑动窗口的 start = 报文确认序号,所以窗口左侧指针不会更新,也就不会跳过实际未接收到的报文,以方便后续的重传机制进行补发。
b. 最左侧报文应答丢失
如果 1001--2000 对应的 2001 应答丢失,由于接收端实际上已经接收到了 1001--2000 的报文数据,所以应答会继续往后更新:收到 2001--3000 就应答 3001......收到 4001--5000 就应答 5001,发送端滑动窗口继续向右滑动,窗口正常工作。
- 中间丢失
中间丢失意味着左侧已经接收到了。根据确认序号的定义以及滑动窗口指针的更新算法,窗口会正常工作,将左侧已接收的数据移出,直到中间丢失的位置,于是"中间丢失"就转化为了"最左侧丢失"。
- 最右侧丢失
同理,"最右侧丢失"也会转化为"最左侧丢失"。
那么,丢包的所有综合情况,就是上面三种情况的自由组合。
所以,滑动窗口不会跳过报文进行应答,发送必须是连续的,也就是说滑动窗口不能跳跃。
再细分:ACK 丢失与数据包丢失
情况一:数据包已经抵达,ACK 被丢了。

图 20:数据包已抵达,但 ACK 丢失
这种情况下,部分 ACK 丢了并不要紧,因为可以通过后续的 ACK 进行确认。
情况二:数据包直接丢了。

图 21:数据包丢失后的重复确认与快重传
先回顾一下确认序号的定义,这一点与本处强相关:确认序号表示该序号之前的报文已经接收到了。
当某一段报文丢失之后,发送端会一直收到 1001 这样的 ACK,就像是在提醒发送端"我想要的是 1001",也就是说,至少可以确定 1001--2000 这个报文一定丢失了。
如果发送端连续三次收到了同样一个 1001 这样的应答,就会将对应的数据 1001--2000 重新发送。这时接收端收到了 1001 之后,再次返回的 ACK 就是 7001 了(因为 2001--7000 接收端其实之前就已经收到,并被放到了接收端操作系统内核的接收缓冲区 中)。这种机制被称为"高速重发控制",也叫快重传。
那么问题又来了:既然有了快重传机制,为什么还要有之前的超时重传机制呢?
其实道理很简单,因为两者的触发条件不一样:快重传要求收到三个相同确认序号的应答,而超时重传是没收到应答且已经超时。如果收不到三个相同确认序号的应答,就必须使用超时重传了------比如只传输两个数据包,根本凑不齐三个重复 ACK。
也就是说,超时重传是一个兜底机制,快重传是一种提高效率的机制,两者相互配合。发出去的所有报文底层都有计时器计时,当接收到三个相同确认序号的 ACK 时,就会优化为快重传,并将计时器取消。
这也就解释了:TCP 将一个报文发出后,不能立即把数据清空,没有应答时要保存起来,以方便后续重传。那么所谓的"保存"是保存到哪里呢?其实就是保存在滑动窗口里面------在没有收到对应的应答之前,滑动窗口不会向右移动,而向右滑动的本质就是将该数据删除。怎么保存?窗口不移动。
所以,超时重传和快重传的底层支持就是滑动窗口,重传的都是滑动窗口里面的数据。

图 22:窗口大小为 4000 字节(四个段)的滑动窗口
窗口大小指的是无需等待确认应答而可以继续发送数据的最大值。上图的窗口大小就是 4000 个字节(四个段)。
- 发送前四个段的时候,不需要等待任何 ACK,直接发送。
- 收到第一个 ACK 后,滑动窗口向后移动,继续发送第五个段的数据,依次类推。
- 操作系统内核为了维护这个滑动窗口,需要开辟发送缓冲区来记录当前还有哪些数据没有应答;只有确认应答过的数据,才能从缓冲区删掉。
- 窗口越大,则网络的吞吐率就越高。
7.4 流量控制
其实,学完滑动窗口之后,流量控制就已经学完了,因为流量控制的底层实现就是滑动窗口。这里再做一下补充说明。
接收端处理数据的速度是有限的。如果发送端发得太快,导致接收端的缓冲区被打满,这个时候如果发送端继续发送,就会造成丢包,继而引起丢包重传等一系列连锁反应。TCP 本身是可靠的,但这些重传会耗费大量网络资源、电力与算力。
因此,TCP 支持根据接收端的处理能力来决定发送端的发送速度,这个机制就叫作流量控制(Flow Control)。
- 接收端将自己可以接收的剩余缓冲区大小放入 TCP 首部中的"窗口大小"字段,通过 ACK 通知发送端。
- 窗口大小字段越大,说明网络的吞吐量越高。
- 接收端一旦发现自己的缓冲区快满了,就会将窗口大小设置成一个更小的值通知给发送端。
- 发送端接收到这个窗口值之后,就会减慢自己的发送速度。
- 如果接收端缓冲区满了,就会将窗口置为 0;这时发送方不再发送数据,双方的 OS 都在等接收端的接收缓冲区何时有空间。但发送端需要定期发送一个窗口探测数据段(一个不带数据的 TCP 报文,因此不会占用对方已经满的缓冲区),接收端仍然要对该报文进行应答,从而把窗口大小告诉发送端。
- 另一种方式是接收端主动通知自己的窗口大小,主动发送一个窗口更新通知的 TCP 报文。
- 两种方式实际上是同时运用的。
那么问题来了:16 位窗口大小最大只能表示 65535,TCP 窗口最大就是 65535 字节吗?
实际上,TCP 首部 40 字节的选项中还包含了一个窗口扩大因子 M ,实际窗口大小是窗口字段的值左移 M 位,也就是:实际窗口大小 = 16 位窗口数值 × 2M。

图 23:TCP 窗口探测与窗口更新
当发送端连续多次(比如系统默认的 10 次左右,总耗时可能长达十几分钟) 发送窗口探测包,而接收端彻底没有任何回应 (连 ACK 都不回),发送端才会判定对方主机可能断电或断网了,从而发出 RST 强行断开连接。
7.5 拥塞控制
前面我们聊到的滑动窗口、确认应答、超时重传,本质上都是两台主机之间在"打配合"(也就是端到端的流量控制)。但这还不够,因为数据在传输时,还要穿过无数台路由器和交换机。
如果通信刚开始,发送端就猛发大量数据,会带来什么灾难?假设发送端一口气发了 1000 个报文,对方只丢了几个,那是正常的网络波动,补发就行;但如果对方只收到了两三个,甚至全军覆没,这就说明网络出大问题了 。大量报文在路由器排队、大面积超时,说明网络已经发生了拥塞。
这时候如果直接触发超时重传会发生什么? 如果只有少量丢包,重发没问题;但如果是海量丢包,此时千万不要立刻重发。因为网络不是某一家独占的,如果你因为拥塞立刻重发,只会给已经拥堵的路由器雪上加霜;更可怕的是,全网的其他主机也都这么干(大家都在重发),最终会引发**"网络雪崩"**,导致整个网络瘫痪。
这时候,TCP 的拥塞控制机制就登场了。它要求所有主机在发现网络拥塞时,必须"集体踩刹车",而不是自私地抢占带宽。
当然,TCP 的能力也是有边界的。它能解决网络逻辑上的拥塞,但如果路由器等底层硬件直接挂了,那谁也没辙。所有的拥塞控制,都必须建立在"网络硬件依然在工作"的前提下。
**怎么踩刹车呢?引入"慢启动"机制。**既然不知道当前网络到底有多堵,那就先别猛发。TCP 会在通信刚开始时,只发极少量的数据去"探探路"。如果这部分数据顺利收到了 ACK,说明网络通畅,那就翻倍增加发送量;如果迟迟没有 ACK,说明路堵了,立刻把发送速度降下来。

图 24:TCP 慢启动
慢启动时前期慢、后期快,前期采用小流量、多频次的发送方式,逐步进行试探性传输。刚开始人人都只发一个,于是网络流量瞬间减少,压力就小了很多,也就可以将历史积压的报文趁现在尽快转发出去。
对于一个主机来说,某个时刻网络很拥堵,那么就实施慢启动:发一个、收一个应答;发两个、收两个......发 16 个、收 16 个,此时就会认为网络状况良好、没有这么堵了,于是继续按指数增长,从而尽快恢复网络通信过程、提高通信效率。所以慢启动是指初始时慢,但是增长速度非常快。
当监测到网络拥塞状况得到缓解、网络畅通时,需迅速采取措施恢复网络的正常通信进程,这也就符合指数函数前期增长慢、后期增长快的特点。
但现在又有一个问题:流量不是由滑动窗口决定吗?不是等于对端接收能力吗?
是的,确实由滑动窗口决定;事实上,它既要把对端接收能力考虑进来,也要结合网络状况,在两者之间做一个平衡。
为了支持慢启动增长算法,TCP 提出了拥塞窗口 。拥塞窗口的本质就是一个 int 类型的变量。
- 发送开始的时候,定义拥塞窗口大小为 1。
- 每次收到一个 ACK 应答,拥塞窗口加 1。
- 每次发送数据包的时候,将拥塞窗口和接收端主机反馈的窗口大小做比较,取较小的值作为实际发送的窗口。
拥塞窗口是一个临界值,在这个值内,网络大概率不拥塞。网络状况是变化的,拥塞窗口大小也会更新(出异常恢复时指数增长,后期稳定后线性增长)。
滑动窗口 = min(对端接收缓冲区剩余大小,拥塞窗口大小)
也就是说,即使通信时对端接受能力很强,但网络不好,那就要听网络的;即使网络很好,但对端接收缓冲区快满了,那就要听接收缓冲区的------谁小听谁的。
所以,滑动窗口不仅仅是流量控制的底层实现,也是拥塞控制的底层实现。
但我们总不能一直指数增长吧?由于滑动窗口 = min(对端接收缓冲区剩余大小,拥塞窗口大小),最后就可能退化成"滑动窗口 = 对端接收缓冲区剩余大小"。假设接收端缓冲区可能非常大(比如 1GB),但这不代表中间的路由器能扛得住这么大的瞬时流量。如果拥塞窗口不加限制地指数级增长,网络又会出现各种问题。
不能一直指数增长,那刚开始为什么要指数增长?为了尽快探测和恢复网络通信。
为了后期不增长得那么快,因此不能使拥塞窗口单纯地加倍。此处引入一个叫作慢启动阈值的概念:当拥塞窗口超过这个阈值的时候,不再按照指数方式增长,而是按照线性方式增长。

图 25:慢启动阈值与拥塞避免
1. 慢启动(指数增长):为了效率
刚开始通信时,为了让数据尽快跑满带宽,TCP 采用指数级增长快速测速,用最快的速度达到一个较高的传输速度。
2. 拥塞避免(线性增长):为了探测
当速度达到阈值后,就不能再猛踩油门了。此时切换为线性增长,每次加 1,小心翼翼地不断探测当前网络所能承受的新的拥塞窗口上限。但这个过程发送的数据量不一定增加,因为对方的接受能力可能已经不足了。也就是说,发 20 个一个都不丢、21 个不丢,23、24......说明网络很好,就要增大拥塞窗口。因此,拥塞窗口的数值就是衡量网络流畅程度的指标,值越大,网络越好。
3. 快速恢复(降速后回升):为了止损与恢复
当网络真的发生拥塞(丢包)时,TCP 会立刻将阈值减半,并降低发送速度,以缓解网络压力。随后,TCP 利用"快重传"和"快速恢复"机制,从降速后的状态开始重新快速攀升,让通信不至于跌入谷底,从而保证整体通信的连贯性。
7.6 拥塞窗口的上限
最后一个问题:如果此时网络特别好,那么拥塞窗口在线性探测的过程中,会一直增大吗?
按理说,网络越强,发送速度就该越快。但实际上,TCP 的拥塞窗口 cwnd 是有绝对上限的,它会被下面三道"上线"压住:
- 接收方的处理能力(rwnd): 实际发送窗口是
min(cwnd, rwnd)。如果对方的内存只有 64KB,你的网络再好、cwnd再大也没用。 - OS 的内存限制: 内核分配给 TCP 发送缓冲区的内存是有上限的,
cwnd不可能突破这个物理内存墙。 - **物理网络的 BDP 与序列号:**带宽再大,管道也是有粗细的,超过物理极限的数据只会堵在路由器里;而且 TCP 的序列号只有 32 位(最大 4GB),传太快会导致序列号回绕。
所以,大部分情况下,网络比较稳定后,拥塞窗口数值相对稳定,ssthresh 值也比较稳定,通信时以对方接受能力为主,这就是网络通信的理想情况了。
拥塞控制,归根结底是 TCP 协议想尽可能快地把数据传输给对方,但又要避免给网络造成太大压力的一种折中方案。
7.7 延迟应答
如果接收数据的主机立刻返回 ACK 应答,这时候返回的窗口可能比较小。
假设接收端缓冲区为 1MB,一次收到了 500KB 的数据;如果立刻应答,返回的窗口就是 500KB。但实际上,可能处理端的速度很快,10ms 之内就把 500KB 数据从缓冲区消费掉了。在这种情况下,接收端处理还远没有达到自己的极限,即使窗口再放大一些,也能处理过来。如果接收端稍微等一会再应答,比如等待 200ms 再应答,那么这个时候返回的窗口大小就是 1MB。
这种通过延迟给对方通告更大的窗口、从而较大概率提高传输数据效率的机制,叫作延迟应答。

图 26:TCP 延迟应答
**Tips:**我们在网络中设计的概率性机制一定是有效的,因为网络通信无处不在、样本足够大,这个优化一定就会起作用。
一定要记得:**窗口越大,网络吞吐量就越大,传输效率就越高。**我们的目标是在保证网络不拥塞的情况下,尽量提高传输效率。
那么,所有的包都可以延迟应答吗?肯定也不是。
- **数量限制:**每隔 N 个包就应答一次。
- **时间限制:**超过最大延迟时间就应答一次。
具体的数量和超时时间依操作系统不同而有差异;一般 N 取 2,超时时间取 200ms。
八、TCP 的特性与总结
TCP 有两个绕不开的特性:面向字节流,以及由它引出的粘包问题。
8.1 面向字节流
- 创建一个 TCP 的 socket,同时在内核中创建一个发送缓冲区 和一个接收缓冲区。
- 调用
write时,数据会先写入发送缓冲区中。 - 如果发送的字节数太长,会被拆分成多个 TCP 数据包发出。
- 如果发送的字节数太短,就会先在缓冲区里等待,等到缓冲区长度差不多了,或者其他合适的时机再发送出去。
- 接收数据的时候,数据也是从网卡驱动程序到达内核的接收缓冲区。
- 然后应用程序可以调用
read从接收缓冲区拿数据。 - 另一方面,TCP 的一个连接既有发送缓冲区,也有接收缓冲区;对于这一个连接,既可以读数据,也可以写数据,这个概念叫作全双工。
由于缓冲区的存在,TCP 程序的读和写不需要一一匹配。例如:
- 写 100 个字节数据时,可以调用一次
write写 100 个字节,也可以调用 100 次write、每次写一个字节;也就是说,报文没有边界。 - 读 100 个字节数据时,也完全不需要考虑写的时候是怎么写的,既可以一次
read100 个字节,也可以一次read一个字节、重复 100 次。
8.2 粘包问题
首先要明确,粘包问题中的"包",指的是应用层的数据包。
- 在 TCP 的协议头中,没有如同 UDP 一样的"报文长度"字段,但是有一个序号字段。
- 站在传输层的角度,TCP 是一个一个报文过来的,会按照序号排好序放在缓冲区中。
- 站在应用层的角度,看到的只是一串连续的字节数据。
- 应用程序看到这样一连串的字节数据,就不知道从哪个部分开始、到哪个部分结束,才是一个完整的应用层数据包。
那么,如何避免粘包问题呢?归根结底就是一句话:明确两个包之间的边界。这也就是"协议 + 序列化 + 反序列化"的应用层工作。
- 对于定长的包: 保证每次都按固定大小读取即可。例如上面的
Request结构是固定大小的,那么就从缓冲区从头开始按sizeof(Request)依次读取。 - **对于变长的包:**可以在包头的位置约定一个"包总长度"的字段,从而知道包的结束位置。
- **对于变长的包:**还可以在包和包之间使用明确的分隔符(应用层协议由程序员自己来定,只要保证分隔符不和正文冲突即可)。
8.3 UDP 是否存在"粘包问题"
思考:对于 UDP 协议来说,是否也存在"粘包问题"呢?
- 对于 UDP,如果还没有向上层交付数据,UDP 的报文长度仍然在;同时,UDP 是一个一个把数据交付给应用层的,因此有很明确的数据边界。
- 站在应用层的角度,使用 UDP 的时候,要么收到完整的 UDP 报文,要么不收,不会出现"半个"的情况。
8.4 TCP 总结
一、TCP 的核心机制
- **保可靠性(绝对不丢不重):**校验和、序列号(保序)、确认应答、超时重发、连接管理(三次握手/四次挥手)、流量控制(管接收端)、拥塞控制(管网络)。
- **提性能:**滑动窗口、快速重传、延迟应答、捎带应答。
- **底层支撑:**各类内核定时器(超时重传定时器、保活定时器、TIME_WAIT 定时器等)。
二、TCP 的异常情况处理
- 进程崩溃 / 机器重启: 操作系统会自动回收文件描述符并发送
FIN,等同于正常关闭。 - 机器掉电 / 网线拔断: 对端毫不知情。如果对端有数据要发,会因收不到
ACK触发超时,最终发RST强制重置;如果没有数据要发,则依靠 TCP 的**保活定时器(Keep-Alive)**定期探测。 - 注:应用层通常也会做自己的心跳保活机制(如 HTTP 长连接检测、QQ 断线重连)。
- 关于连接保活机制: 当连接没有任何数据传输长达 2 小时(默认)时,TCP 会定期发送探测包去试探对方。如果连续多次都没有响应,内核就会判定对方已死,强制释放连接。
三、TCP 与 UDP
没有绝对的优劣,只有最适合的场景:
- TCP: 用于要求绝对可靠的场景(文件传输、支付状态更新等)。
- UDP: 用于要求高速、实时性的场景(音视频流、早期 QQ、广播等)。
四、经典面试题:如何用 UDP 实现可靠传输?
核心思路:把 TCP 的机制搬到应用层自己实现。
- 引入序列号(保证乱序重组)。
- 引入确认应答 ACK(确保对方收到)。
- 引入超时重传(丢包兜底)。
(这也是现代 QUIC / HTTP/3 协议的底层逻辑)
附:一条 fd 在内核里走了多远?
前面讲的连接、缓冲区、滑动窗口,都是"结果"。回到操作系统层面,我们在代码里拿到的其实只有一个
int类型的 fd。从这个简单的数字出发,内核要跳几次指针,才能找到那个真正负责收发数据的 TCP 控制块?请看"文件描述符到内核 TCP 对象的关联链路":
图中的蓝色箭头表示指针指向,红色箭头表示
private_data与struct file之间的双向关联,嵌套方框表示结构体之间的"内嵌"。这其实就是 Linux "一切皆文件" 思想在底层的完美落地。一次
read/write,在内核里的寻址路径大致如下:
task_struct:进程控制块,指向该进程的文件表。
struct files_struct:记录进程打开的所有文件。你拿到的fd,仅仅是它内部fd_array[]数组的下标。
struct file:VFS(虚拟文件系统)层中"一个已打开的文件",记录了读写偏移、权限等。其中的private_data用来挂载具体文件类型的私有数据。
struct socket:socket 层的抽象。它既有一条file指针回指上层,也持有真正干活的内核对象sk。fd经过 VFS 层后,通过private_data强转成这个结构。
struct sock:传输层的通用基类。
inet_sock→inet_connection_sock→tcp_sock:通过逐层内嵌 (C 语言实现继承的方式),越往里越"TCP 专用"。序号、窗口、重传与拥塞控制的所有字段,都藏在这最里层的tcp_sock上。关于继承(强转) :通过层层内嵌,
tcp_sock的最外层就是sock。因为 C 语言结构体的首成员地址与结构体地址相同,所以把sock强转为tcp_sock,根本不需要拷贝,指针原地就能直接访问 TCP 的专属字段(如滑动窗口)。关于多态(函数指针) :在顶层的
struct sock里,维护了一个struct proto *sk_prot的协议操作表。无论是 TCP 还是 UDP,上层网络层都统一调用sk->sk_prot->sendmsg()。底层的函数指针会自动路由到 TCP 或 UDP 的具体实现函数上。图中左下角的
sk_receive_queue和sk_write_queue就挂在struct sock上,这是**"TCP 连接有状态"最直观的证据**:数据到没到、发没发出去、该重传谁,内核全靠这两个队列来记账。小结 :
一次系统调用,在内核里大致是这条路:
fd → fd_array[fd] → struct file → private_data → struct socket → sk → tcp_sock。为了找到一个连接,内核要跳这么多次指针、做多次类型转换,所以每个 TCP 连接都是实打实的内存与 CPU 开销
