首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >连接超时和读超时到底管什么?用 Python 把 TCP 的几种「卡住」逐个复现

连接超时和读超时到底管什么?用 Python 把 TCP 的几种「卡住」逐个复现

原创
作者头像
用户12904616
发布于 2026-11-20 10:23:57
发布于 2026-11-20 10:23:57
120
举报

先说结论: 一次 HTTP 请求至少有三个时间需要分别控制:连接超时管 TCP 三次握手要等多久,读超时管「两次收到数据之间」最长等多久,总时限管整个请求最多花多久。前两个 requests 都支持,写成 timeout=(连接, 读);第三个 requests 没有,要自己实现。不设超时的后果分别是:连不上的地址在 macOS 上要等 75 秒才报错(Linux 默认更久),对方不回数据就永远等下去,对方慢慢挤数据则读超时永远不会触发。下面在 macOS 上用 Python 3.12、requests 2.34 把这些情况逐个复现,所有输出都是实测。

几种「连不上」和「等不到」

先区分清楚,因为它们的表现和处理方式完全不同:

现象

网络上发生了什么

多快报错

连接被拒绝

对方主机在,但端口没有程序监听,回了 RST

立即

连接超时

SYN 发出去没有回应(地址不通、被防火墙丢弃)

取决于连接超时

读超时

连接建好了,请求也发了,对方一直不回

取决于读超时

慢速响应

对方在回,但每次只回一点点

读超时不触发,取决于总时限

测试环境

两个故意出问题的服务端:18108 端口收到请求后一个字节都不回;18109 端口先回响应头,然后每秒挤出 1 个字节,共 12 个字节。

代码语言:javascript
复制
# slow_servers.py
import socket, threading, time

def silent(c):                 # 读完请求,然后什么也不回
    c.recv(65536)
    time.sleep(60)
    c.close()

def drip(c):                   # 回响应头,之后每秒 1 个字节
    c.recv(65536)
    c.sendall(b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\nConnection: close\r\n\r\n")
    for b in b"hello world\n":
        time.sleep(1)
        c.sendall(bytes([b]))
    c.close()

def serve(port, fn):
    s = socket.create_server(("127.0.0.1", port), backlog=64)
    while True:
        c, _ = s.accept()
        threading.Thread(target=fn, args=(c,), daemon=True).start()

threading.Thread(target=serve, args=(18108, silent), daemon=True).start()
serve(18109, drip)

「连不上」的情况用 10.255.255.1 模拟。这是一个私有网段地址,在我的网络里没有任何设备会回应,发过去的 SYN 石沉大海。

实验一:不设超时,连一个不通的地址要等多久

代码语言:javascript
复制
import socket, time
t = time.monotonic()
try:
    socket.create_connection(("10.255.255.1", 80))
except OSError as e:
    print(repr(e), round(time.monotonic() - t, 1))
代码语言:javascript
复制
TimeoutError(60, 'Operation timed out') 75.0

75 秒。这是操作系统自己的 SYN 重传上限,macOS 上大约是 75 秒。Linux 由 net.ipv4.tcp_syn_retries 决定,默认 6 次重传,按指数退避算下来是两分钟出头。一个处理请求的线程在这里卡一两分钟,在高并发服务里足以把线程全部耗光。

实验二:连接阶段的三种结果

代码语言:javascript
复制
import socket, time
import requests

def timed(label, fn):
    t = time.monotonic()
    try:
        out = fn()
        print(f"{label}: 成功 {out!r},{time.monotonic() - t:.1f}s")
    except Exception as e:
        print(f"{label}: {type(e).__name__}: {e},{time.monotonic() - t:.1f}s")

timed("socket 连不通的地址,timeout=3", lambda: socket.create_connection(("10.255.255.1", 80), timeout=3))
timed("socket 连没监听的端口", lambda: socket.create_connection(("127.0.0.1", 18105), timeout=3))
timed("requests 连不通的地址", lambda: requests.get("http://10.255.255.1/", timeout=(3, 10)))
timed("requests 连没监听的端口", lambda: requests.get("http://127.0.0.1:18105/", timeout=(3, 10)))
代码语言:javascript
复制
socket 连不通的地址,timeout=3: TimeoutError: timed out,3.0s
socket 连没监听的端口: ConnectionRefusedError: [Errno 61] Connection refused,0.0s
requests 连不通的地址: ConnectTimeout: HTTPConnectionPool(host='10.255.255.1', port=80): Max retries exceeded with url: / (Caused by ConnectTimeoutError(<HTTPConnection(host='10.255.255.1', port=80) at 0x10895c290>, 'Connection to 10.255.255.1 timed out. (connect timeout=3)')),3.0s
requests 连没监听的端口: ConnectionError: HTTPConnectionPool(host='127.0.0.1', port=18105): Max retries exceeded with url: / (Caused by NewConnectionError("HTTPConnection(host='127.0.0.1', port=18105): Failed to establish a new connection: [Errno 61] Connection refused")),0.0s

几个要点:

  • 「连接被拒绝」不需要等,对方用 RST 立即告诉你没人在听。看到 Connection refused,查的是对方服务有没有启动、端口对不对,和超时设置无关。
  • 「连接超时」是 ConnectTimeout,报错里写明了 connect timeout=3。
  • 报错里的 Max retries exceeded 容易让人误会。这里一次重试都没有发生,requests 默认不重试,只是 urllib3 的报错模板就是这么写的。

实验三:读超时

代码语言:javascript
复制
timed("服务端不回,timeout=(3, 5)", lambda: requests.get("http://127.0.0.1:18108/", timeout=(3, 5)))
timed("timeout=5(单个数字),服务端不回", lambda: requests.get("http://127.0.0.1:18108/", timeout=5))
代码语言:javascript
复制
服务端不回,timeout=(3, 5): ReadTimeout: HTTPConnectionPool(host='127.0.0.1', port=18108): Read timed out. (read timeout=5),5.0s
timeout=5(单个数字),服务端不回: ReadTimeout: HTTPConnectionPool(host='127.0.0.1', port=18108): Read timed out. (read timeout=5),5.0s

timeout 写一个数字时,连接和读用同一个值;写成元组可以分开设。连接超时通常设得短一些(几秒就够,正常网络下三次握手只需要一个往返),读超时按接口的正常响应时间设,留出余量。

不设 timeout 时,requests 的默认值是 None,也就是永远等待。 这一点在 requests 文档里专门提醒过:生产代码里几乎所有请求都应该带 timeout。

实验四:读超时管不住「慢」

代码语言:javascript
复制
timed("服务端每秒 1 字节,timeout=(3, 5)", lambda: requests.get("http://127.0.0.1:18109/", timeout=(3, 5)).text)
代码语言:javascript
复制
服务端每秒 1 字节,timeout=(3, 5): 成功 'hello world\n',12.1s

读超时是 5 秒,请求却花了 12 秒,而且成功了。因为读超时是每次等待数据的上限,不是整个响应的上限。服务端每秒都在发数据,每次等待都不超过 1 秒,读超时永远不会触发。只要对方一直这样挤,请求可以持续任意长的时间。

实现一个总时限

requests 没有总时限参数,常见做法是用流式读取,每收到一块数据检查一次已用时间:

代码语言:javascript
复制
import time
import requests

def get_with_deadline(url, deadline, timeout=(3, 5)):
    start = time.monotonic()
    body = bytearray()
    with requests.get(url, stream=True, timeout=timeout) as r:
        while chunk := r.raw.read1(65536, decode_content=True):   # 有多少拿多少
            body += chunk
            if time.monotonic() - start > deadline:
                raise TimeoutError(f"超过总时限 {deadline}s,已收到 {len(body)} 字节")
    return bytes(body)
代码语言:javascript
复制
超过总时限 6s,已收到 6 字节,6.0s

这里有两个我实际踩到的坑:

坑一:iter_content() 不行。 我最开始用的是 for chunk in r.iter_content(chunk_size=1024),结果仍然等了 12.1 秒才返回,chunk_size=None 也一样。原因是 urllib3 2.x 的 read(amt) 会尽量凑够 amt 个字节才返回,对方每秒只来 1 个字节,它就一直等到连接关闭,循环体里的时间检查根本没机会执行。read1() 每次最多做一次底层读取,有数据就返回,检查才能及时发生。

坑二:read1() 默认返回压缩后的数据。 我对一个启用了 gzip 的网站测试,不带 decode_content=True 时拿到 400 字节,带上之后是 577 字节,和 r.content 的长度一致。requests 创建底层响应对象时关闭了自动解压,由它自己的 iter_content 负责解压;绕过它直接读 r.raw,就要自己要求解压。

这个总时限仍然是「每次收到数据后检查」。如果对方在中途完全停止发送,靠的是读超时兜底,所以两者要配合使用:读超时管「完全不动」,总时限管「一直在动但太慢」。

还有两个不受超时控制的地方

  • 域名解析。 requests 的连接超时从建立 TCP 连接开始算,之前的 DNS 解析调用的是系统的 getaddrinfo,不受这个超时控制。解析服务器不通时,卡在解析上的时间由系统的解析配置决定(Linux 上是 /etc/resolv.conf 里的 timeout 和 attempts)。对解析时间敏感的服务,可以在机器上部署本地缓存,或者在应用层先单独解析。
  • 一个域名对应多个 IP。 urllib3 建连时会按 getaddrinfo 返回的顺序逐个尝试,每个地址各自享有完整的连接超时。一个域名有 3 个地址且都不通,连接超时 3 秒,最坏要等 9 秒才报错。

推荐的写法

代码语言:javascript
复制
import requests

session = requests.Session()               # 复用连接,少建连就少一次可能超时的握手

def call(url):
    # 连接 3 秒,读 10 秒;需要总时限时用上面的 get_with_deadline
    return session.get(url, timeout=(3.05, 10))

连接超时写成 3.05 而不是 3,来自 requests 文档的建议:把连接超时设成略大于 3 的倍数,理由是早期 TCP 实现的 SYN 重传间隔以 3 秒为单位。现在的 Linux 首次重传间隔已经是 1 秒,这个建议的实际影响不大,但写成 3.05 也没有坏处。

最后整理成一张表:

超时

requests 写法

管什么

不设的后果

连接超时

timeout=(3.05, ...)

三次握手

macOS 约 75 秒、Linux 两分钟以上才报错

读超时

timeout=(..., 10)

两次收到数据的间隔

对方不回就永远等

总时限

自己实现

整个请求

对方慢慢发,请求可以无限长

解析超时

系统解析配置

域名解析

由 /etc/resolv.conf 决定

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

目录
  • 几种「连不上」和「等不到」
  • 测试环境
  • 实验一:不设超时,连一个不通的地址要等多久
  • 实验二:连接阶段的三种结果
  • 实验三:读超时
  • 实验四:读超时管不住「慢」
  • 实现一个总时限
  • 还有两个不受超时控制的地方
  • 推荐的写法
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档