一个很常见的上线事故:压测环境一切正常,连接一两毫秒就建好;上线后客户端开始报超时,日志里全是“连接建立失败”,服务端却看起来风平浪静,CPU 不高,日志也没报错。把流量降下来,过一会儿又自己好了。开发怀疑是网络抖动,运维怀疑是防火墙,两个人各查了半天,最后发现服务端监听队列设得太小,瞬间涌进来的连接把队列塞满了。

这个故障的关键在于,“连接建立”这件事在服务端分成了两段:内核先把握手做完,把连接放进一个队列;应用调用接受连接的接口,再从队列里取走。队列满了以后,新的握手请求会被丢掉或者晾着,客户端只能一遍遍重试。服务端应用完全不知道自己漏掉了什么,因为它从头到尾都没收到那些连接。

这篇就把这件事拆开:三次握手到底确认了什么、为什么是三次而不是两次、队列在哪、满了会怎样;然后对比 TCP 和 UDP 各自保证什么、不保证什么,最后解释四次挥手和那个总被问到的 TIME_WAIT。

现象:连接超时,但服务端“什么都没发生”

先建立一个直觉:TCP 是一条“有状态的管道”。双方内核都记着这条连接的序号、窗口、状态机位置。连接建立不是一个瞬间动作,而是一段协商过程。协商成功,双方进入“已建立”状态,之后才能可靠地传数据;协商失败,客户端看到的是超时或拒绝,服务端可能连记录都没有。

超时和拒绝是两种不同的信号。收到拒绝,通常说明对方的操作系统明确回了一个重置包,意思是“这个端口没人听,别等了”。一直超时,说明包被丢了,或者对方压根没回。前者能立刻定位到端口或服务没起来,后者则要怀疑链路、防火墙、队列,排查成本高得多。

“本地测试秒连”很容易骗人,因为本机回环几乎不丢包、延迟接近零,握手一瞬间就完成;真实网络里一个握手要一个往返,跨地域就是几十毫秒,连接一多,队列堆积的速度远超应用取走的速度。所以本地压测通过,不能证明连接容量够用。

三次握手在确认三件事

握手过程本身很短:客户端发一个带 SYN 标志的包,里面写着自己的初始序号;服务端回一个 SYN 加 ACK,既确认收到对方的序号,也报出自己的初始序号;客户端再回一个 ACK 确认收到。三句话说完,双方都确认了“你能发给我、我能发给你”,并且交换了起始序号。

为什么不是两次?因为只发两次的话,服务端无法确认“客户端真的收到了我的 SYN”。第三次的 ACK 看似多余,实际是在验证回程方向也通。更本质地说,三次握手让双方都获得了一个“对方知道我在”的证据,同时把两个方向的初始序号都对齐,避免旧连接残留的包被误认成新连接的数据。

握手期间还会协商参数:最大报文段长度、窗口缩放因子、是否启用时间戳、是否启用选择确认。这些选项决定了后面传输的效率和正确性。你在抓包里看到 SYN 包特别大,往往就是因为带了一串选项。选项谈不拢,有的实现会退化到保守值,表现就是“能连上但吞吐上不去”。

还有一件事握手不保证:它不证明服务端应用“准备好了”。内核可以在应用还没调用接受连接之前就完成握手,把连接堆在队列里。所以“端口能连上”只说明内核在听,不代表业务能处理。这就是为什么健康检查只做端口探测是不够的,它会让一个已经卡死的服务看起来仍然健康。

走查:一个连接从 SYN 到进队列

握手与队列
客户端发 SYN带上自己的初始序号和协商选项,进入“已发送”状态
服务端收 SYN内核在半连接队列里建一条记录,回 SYN 加 ACK
客户端回 ACK确认服务端序号,双方内核进入“已建立”
连接入队内核把这条已建立的连接放进接受队列,等应用来取
应用取走调用接受连接的接口,拿到一个新的套接字,开始读写

这里有两条队列,名字容易混。半连接队列放的是“收到了 SYN、还没完成握手”的记录;接受队列放的是“握手已完成、等应用取走”的连接。两条队列都有上限。半连接队列满了,新的 SYN 会被丢弃或降级处理;接受队列满了,常见的做法是不再回应新的握手,让客户端自己重试。

很多教程只提“连接队列”,实际上线时两种溢出都会遇到。被 SYN 洪水打的时候是半连接队列满;应用处理慢、来不及取连接时是接受队列满。前者通常伴随大量伪造源地址,后者往往只是应用卡住了,比如在取连接之前做了件很慢的事。

应用侧还有一个常见写法会加剧问题:把接受连接和业务处理放在同一个循环里。取到一条连接就同步处理到结束,期间不再取新的。连接一多,接受队列迅速堆满,后面的握手就被晾着。正确做法是把接受连接和处理业务分开,取到就交给别的线程或事件循环。

实测:把监听队列设成 1,看它怎么满

这段代码故意不调用接受连接,只监听,然后把 backlog 设成 1,连续发起五次连接。本机 Python 3.15,Windows。

import socket, time

s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(("127.0.0.1", 0))
s.listen(1)
addr = s.getsockname()
print("listen", addr)

res = []
for i in range(5):
    t0 = time.perf_counter()
    try:
        c = socket.create_connection(addr, timeout=0.5)
        c.close()
        res.append(("ok", round((time.perf_counter() - t0) * 1000, 1)))
    except OSError as e:
        res.append((type(e).__name__, round((time.perf_counter() - t0) * 1000, 1)))
print(res)

实际输出:

listen ('127.0.0.1', 60380)
[('ok', 24.5), ('TimeoutError', 500.7), ('TimeoutError', 514.5), ('TimeoutError', 509.7), ('TimeoutError', 509.0)]

第一条连接 24.5 毫秒就建好了,说明握手本身很快;后四条全部卡到超时上限才返回。原因就是我们从头到尾没有接受连接,队列容量只有 1,第一条占满之后,后面几条的握手请求得不到回应。客户端的 500 毫秒是它自己设的等待上限,不是网络真的走了 500 毫秒。

这个实验还暴露了一个重要细节:服务端没有任何报错。它只是静静地不再回应。真实系统里,这就是“客户端超时、服务端无感”的来源。要确认是不是这个问题,得看内核的连接队列统计,而不是看应用日志。Linux 上可以看 ss -lnt 里监听的 Send-Q 和 Recv-Q,再用 netstat -s 里的溢出计数佐证;本机没有 Linux 环境,这一步未在本机实测。

顺带一个补充实验:往一个没有监听的本地端口发起连接,本机等了一秒左右才超时,而不是立刻拒绝。原因是本机的防火墙把这类探测当成丢弃处理。UDP 那边更直接,向关闭的端口发数据,随后读取会收到一个连接重置的错误,因为对方回了“端口不可达”的 ICMP 报文。这两个结果说明:同一种“失败”,在不同的协议和不同的防火墙策略下,表现可以完全不同。

延迟方面,本机回环上做了两千次一问一答,TCP 平均 39.2 微秒,UDP 平均 37.6 微秒,差别很小。这个数字不能拿来证明“TCP 比 UDP 慢很多”,因为在回环上没有真实链路的往返、没有丢包、没有拥塞。它只能说明:协议本身的处理开销在同一量级,真正的差距来自可靠性机制在恶劣网络下的行为。

TCP 和 UDP 到底差在哪

TCP:先建管道,再送数据

有连接状态,双方各自维护序号和窗口;丢包会重传,乱序会重排,重复会去重;发送过快会被流量控制和拥塞控制拉住。头部至少 20 字节,还要为每条连接在内核里存一份状态。

代价是建立连接要一个往返,断线要能感知,状态多了会占内存。适合“不能错、不能少”的场景:网页、接口调用、文件传输、数据库连接。它保证的是“字节流按序、完整地送达”,不保证“消息边界”,也不保证时限。

UDP:直接扔出去

无连接,头部 8 字节,发出去就不管了;不重传、不排序、不做流量控制,应用自己决定怎么处理丢包和乱序。一个包就是一条消息,边界天然保留。

代价是网络一变差,应用要自己兜底:自己编号、自己重传、自己控速。适合“延迟比完整更重要”的场景:实时音视频、游戏同步、日志上报、DNS 查询。很多新协议(比如 QUIC)就是在 UDP 之上自己重建了可靠性,图的是不被中间设备按 TCP 特征干扰。

有一个常见误解:UDP 一定比 TCP 快。在干净的局域网里,两者差别很小;在丢包严重的链路上,UDP 没有重传,所以“看起来快”,但可能丢了关键数据;TCP 会重传,延迟上去了,数据是完整的。选哪个,取决于你更怕“慢”还是更怕“缺”。

另一个误解是“TCP 可靠,所以用它就万事大吉”。TCP 只保证送达和顺序,不保证时间。连接卡住时,它可能重传好几分钟才放弃,业务早就超时了。所以应用层还得有自己的超时和重试,而且重试要幂等,否则会把一次失败放大成多次副作用。

四次挥手和那两条让人误解的状态

关闭连接之所以要四次,是因为两个方向要各自关一次。主动关闭方发 FIN 表示“我没数据要发了”,对方回 ACK 表示收到;此时反方向可能还有数据在传,等它也发完,再发一个 FIN,主动方再回 ACK。每一步单独确认,所以是四次。如果两边几乎同时关,或者把确认和关闭合并,实际抓包可能只看到三次,这也是正常的。

主动关闭的一方最后会进入 TIME_WAIT,等一段时间才真正释放。等的原因有两个:一是保证最后一个确认能到达对方,如果它丢了,对方重发的 FIN 还能被正确回应;二是让这条连接残留的旧包在网络里自然消亡,避免它们被误认为新连接的数据。等待时间通常是两倍报文最大生存时间,实际实现常见几十秒。

被动关闭的一方容易停在 CLOSE_WAIT。这个状态的含义是“对方已经关了,我还没关”,通常是应用没有及时释放连接,比如忘了关闭、异常路径漏了、或者连接池只借不还。CLOSE_WAIT 大量堆积基本可以断定是代码问题,不是网络问题;而 TIME_WAIT 大量堆积通常是短连接太多,属于设计问题,可以靠连接复用缓解。

本机实测统计过连接状态,当时 TIME_WAIT 只有个位数,监听状态的连接有几十条,说明这台机器上的短连接并不多。这个数字本身没有意义,有意义的是趋势:如果 TIME_WAIT 随请求量线性上涨,就该考虑改用长连接或调整端口复用策略。

现象对照表

现象真实原因第一步查什么
客户端大量连接超时,服务端没日志接受队列满,握手被丢弃或不再回应看监听队列的当前长度和溢出计数
端口能连上,但业务一直没响应握手是内核完成的,应用没在处理看应用是否卡在接受连接之后的第一步
偶发连接被重置,重试就好中间设备超时清理、防火墙策略或服务端主动关闭两端同时看连接状态和重置包的方向
CLOSE_WAIT 数量持续上涨应用收到对方关闭后没有关闭自己的套接字查代码里的异常分支和连接归还逻辑
TIME_WAIT 数量很多短连接太多,主动关闭方集中出现统计连接复用率,考虑长连接或连接池
大文件传到一半卡住路径 MTU 变小,大包被静默丢弃比对两端 MSS,尝试调小
UDP 服务偶发丢消息缓冲区满或网络丢包,协议本身不补偿看接收缓冲区溢出计数和应用层编号缺口
TCP 吞吐上不去但延迟正常窗口太小或丢包导致拥塞窗口收缩看重传率和窗口变化,而不是只看带宽

边界与代价

TCP 的第一层代价是延迟:握手一个往返,慢启动又要花时间才能把速率提上去。请求很小、连接很多时,这些固定成本会主导总耗时。第二层代价是内存:每条连接都要在内核里存状态,还要占发送和接收缓冲区,连接数上万时内存和调度都会吃紧。第三层代价是队头阻塞:一个字节丢了,后面的字节即使到了也要等它重传,整个流被卡住。

UDP 的代价反过来:它把复杂度推给了应用。你要自己做序号、做重传、做拥塞控制,做不好就是“时快时慢还丢数据”。而且 UDP 在公网上并不总是畅通,有些网络会限制它,这时要么回退到 TCP,要么用加密隧道伪装成别的流量。

现代的做法往往是混合的:用 UDP 承载实时数据,用 TCP 承载控制信令;或者像 QUIC 那样在 UDP 上实现可靠传输和加密,把队头阻塞按流拆开。它们的共同点是承认“没有一种传输能同时满足低延迟、高可靠、低开销”,只能在具体场景里取舍。

最后提醒一句:不要用“协议应该是这样”去解释线上现象。中间设备、操作系统参数、应用写法都会改变结果。抓包看到的重传、重置、超时,才是最终事实。协议文档告诉你可能性,实测告诉你这一台机器上的现实。

当天能自己验证的练习

  1. 把上面的 backlog 实验跑一遍,把 listen(1) 改成 listen(5),看第几条连接开始超时,理解队列容量与并发的关系。
  2. 把超时时间从 0.5 秒改成 0.1 秒和 2 秒各跑一次,确认超时时间是你自己设的,不是网络真的走了那么久。
  3. 用 Get-NetTCPConnection 或 netstat 查一次本机的 TIME_WAIT 和 CLOSE_WAIT 数量,然后在浏览器里连续刷新同一个页面,再看一次差值。
  4. 对一个关闭的 UDP 端口发一个包再读一次,观察本机的连接重置错误;换成 TCP 对关闭端口连接,比较两种失败的表现。
  5. 在浏览器开发者工具里找一个耗时长的请求,看它的“连接开始”到“首字节”之间的时间,粗略对应握手加首包。本机没有 Linux 和 tcpdump,内核队列与抓包验证未在本机实测。

小结与下一篇

三次握手确认的是双向可达和初始序号,不是“业务可用”;服务端把已建立的连接放进队列,队列满了就会静默丢连接,于是出现“客户端超时、服务端无感”。TCP 用状态换可靠,UDP 用简单换自由,各自的代价都真实存在。四次挥手是两个方向各关一次,TIME_WAIT 是主动关闭方的等待,CLOSE_WAIT 堆积则多半是应用没关连接。

下一篇讲输入网址之后,第一件事是问谁:DNS 解析。连接能建起来,前提是你先知道对方的 IP;而从域名到 IP 的这一跳,往往在你还没发出第一个包之前就已经决定了成败。