先说结论: 一次 HTTP 请求至少有三个时间需要分别控制:连接超时管 TCP 三次握手要等多久,读超时管「两次收到数据之间」最长等多久,总时限管整个请求最多花多久。前两个 requests 都支持,写成 timeout=(连接, 读);第三个 requests 没有,要自己实现。不设超时的后果分别是:连不上的地址在 macOS 上要等 75 秒才报错(Linux 默认更久),对方不回数据就永远等下去,对方慢慢挤数据则读超时永远不会触发。下面在 macOS 上用 Python 3.12、requests 2.34 把这些情况逐个复现,所有输出都是实测。
先区分清楚,因为它们的表现和处理方式完全不同:
现象 | 网络上发生了什么 | 多快报错 |
|---|---|---|
连接被拒绝 | 对方主机在,但端口没有程序监听,回了 RST | 立即 |
连接超时 | SYN 发出去没有回应(地址不通、被防火墙丢弃) | 取决于连接超时 |
读超时 | 连接建好了,请求也发了,对方一直不回 | 取决于读超时 |
慢速响应 | 对方在回,但每次只回一点点 | 读超时不触发,取决于总时限 |
两个故意出问题的服务端:18108 端口收到请求后一个字节都不回;18109 端口先回响应头,然后每秒挤出 1 个字节,共 12 个字节。
# 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 石沉大海。
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))TimeoutError(60, 'Operation timed out') 75.075 秒。这是操作系统自己的 SYN 重传上限,macOS 上大约是 75 秒。Linux 由 net.ipv4.tcp_syn_retries 决定,默认 6 次重传,按指数退避算下来是两分钟出头。一个处理请求的线程在这里卡一两分钟,在高并发服务里足以把线程全部耗光。
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)))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几个要点:
Connection refused,查的是对方服务有没有启动、端口对不对,和超时设置无关。ConnectTimeout,报错里写明了 connect timeout=3。Max retries exceeded 容易让人误会。这里一次重试都没有发生,requests 默认不重试,只是 urllib3 的报错模板就是这么写的。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))服务端不回,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.0stimeout 写一个数字时,连接和读用同一个值;写成元组可以分开设。连接超时通常设得短一些(几秒就够,正常网络下三次握手只需要一个往返),读超时按接口的正常响应时间设,留出余量。
不设 timeout 时,requests 的默认值是 None,也就是永远等待。 这一点在 requests 文档里专门提醒过:生产代码里几乎所有请求都应该带 timeout。
timed("服务端每秒 1 字节,timeout=(3, 5)", lambda: requests.get("http://127.0.0.1:18109/", timeout=(3, 5)).text)服务端每秒 1 字节,timeout=(3, 5): 成功 'hello world\n',12.1s读超时是 5 秒,请求却花了 12 秒,而且成功了。因为读超时是每次等待数据的上限,不是整个响应的上限。服务端每秒都在发数据,每次等待都不超过 1 秒,读超时永远不会触发。只要对方一直这样挤,请求可以持续任意长的时间。
requests 没有总时限参数,常见做法是用流式读取,每收到一块数据检查一次已用时间:
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)超过总时限 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,就要自己要求解压。
这个总时限仍然是「每次收到数据后检查」。如果对方在中途完全停止发送,靠的是读超时兜底,所以两者要配合使用:读超时管「完全不动」,总时限管「一直在动但太慢」。
getaddrinfo,不受这个超时控制。解析服务器不通时,卡在解析上的时间由系统的解析配置决定(Linux 上是 /etc/resolv.conf 里的 timeout 和 attempts)。对解析时间敏感的服务,可以在机器上部署本地缓存,或者在应用层先单独解析。getaddrinfo 返回的顺序逐个尝试,每个地址各自享有完整的连接超时。一个域名有 3 个地址且都不通,连接超时 3 秒,最坏要等 9 秒才报错。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 删除。