很多爬虫团队在架构升级时,都有过一个看似稳妥的决定:业务早期的 requests 并发不够用了,想切到异步协程,但嫌 aiohttp 接口写起来啰嗦,于是选了号称“下一代 requests”的 httpx。
先说结论,再说为什么。
在本地直连环境下,httpx 和 aiohttp 的体感差距并不大。可一旦挂上隧道代理,把并发拉到 100 甚至 200 以上,三者的性能曲线会立刻发生剧烈分叉。在 200 并发代理压测下,aiohttp 的有效 QPS 是 httpx 的 1.7 倍以上,进程峰值内存却只有多线程 requests 的四分之一。httpx 赢在 API 亲和度与 HTTP/2 原生支持,但在高并发代理隧道的频繁连接抖动面前,它的纯 Python HTTP 解析层和默认连接池限制,往往会比业务目标站更早触及单核 CPU 天花板。
往下拆一层看,这背后的账全算在连接池调度、协议解析器以及隧道握手机制上。
一、为什么不能用本地回环接口做基准?
很多基准测试喜欢在本地起一个 FastAPI 服务返回固定字符串来测 QPS,这种数据在爬虫工程里几乎没有参考意义。真实采集的瓶颈从来不在本机回环网卡,而在公网 RTT 延迟、TLS 加密握手以及代理网关的转发效率。
为了剥离免费公开节点自身丢包、超时对结果的污染,本次实测在一台 4 核 8G Linux 云主机(Python 3.11.8)上进行,目标接口采用支持标准响应头回显的 HTTPS 测试端点,网络出口统一接入亿牛云提供的爬虫加强版隧道代理网关(tn.16yun.cn:9020)。单轮测试共发起 2000 次请求,分别在 20、100、200 三个并发梯度下记录总耗时、P95 延迟、峰值内存与单核 CPU 占用。
客户端配置保持生产级对齐:requests 2.31.0 配合 ThreadPoolExecutor 与自定义 HTTPAdapter(pool_maxsize=并发数);httpx 0.27.0 使用 AsyncClient 并显式放开 Limits(max_connections=并发数, max_keepalive_connections=50);aiohttp 3.9.5 使用 ClientSession 配合 TCPConnector(limit=并发数, limit_per_host=0, ttl_dns_cache=300)。
二、压测大盘:并发一拉高,三者立刻拉开身位
在 20 并发的轻负载下,三者几乎处于同一水平线:requests 线程池跑出 42 QPS,httpx 跑出 48 QPS,aiohttp 跑出 51 QPS。此时网络传输等待占主导,框架本身的调度损耗微乎其微。
但当并发梯度拉升到 100 和 200 时,实测大盘呈现出截然不同的走势:
| 客户端方案 | 并发数 | 有效 QPS | P95 延迟 | 进程峰值内存 | 单核 CPU 峰值占用 |
|---|---|---|---|---|---|
| requests + 线程池 | 100 | 118 req/s | 1.12s | 168 MB | 64% |
| httpx (AsyncClient) | 100 | 152 req/s | 0.89s | 74 MB | 78% |
| aiohttp (ClientSession) | 100 | 235 req/s | 0.56s | 52 MB | 41% |
| requests + 线程池 | 200 | 146 req/s | 1.85s | 312 MB | 92% |
| httpx (AsyncClient) | 200 | 198 req/s | 1.34s | 108 MB | 96% |
| aiohttp (ClientSession) | 200 | 342 req/s | 0.72s | 68 MB | 58% |
这里有两个很值得注意的信号。
其一,requests 开到 200 线程时,内存从 168 MB 飙到 312 MB,但 QPS 仅仅提升了 23%,P95 延迟却恶化到 1.85 秒。多线程上下文切换加上每个线程独立的 SSL 上下文缓存,在 200 并发下已经把大量算力耗死在了 GIL 争抢上。
其二,httpx 的内存控制得足够优秀(108 MB),可单核 CPU 在 200 并发时先一步打到了 96%,吞吐卡在 198 QPS 无法继续攀升。而 aiohttp 在同并发下只用了 58% 的单核 CPU,吞吐直接冲上 342 QPS。
三、深度归因:同样跑 asyncio,差距到底出在哪?
第一层差距在解析器。aiohttp 底层默认采用 C 扩展编写的 llhttp 处理 HTTP 报文拆包,生产环境还能无缝挂载 uvloop 接管事件循环。而 httpx 底层的 httpcore 与 h11 是纯 Python 实现的 Sans-I/O 状态机。纯 Python 状态机代码极度整洁,但在每秒需要解析数百个代理转发响应头、处理各种不规范 Cookie 和 Chunked 分块时,字符串切片和状态转移的开销会迅速吃满单核 CPU,反过来拖慢整个事件循环的协程唤醒。
第二层差距在连接池默认策略。这地方很多人踩坑:httpx.AsyncClient 默认的 Limits 是 max_connections=100、max_keepalive_connections=20。如果不手动调大这两个参数,哪怕业务层用信号量开了 300 个协程,实际在网络层并发的永远只有 100 个,多出来的全在队列里死等甚至触发 PoolTimeout。而 aiohttp 的坑刚好相反:它默认 limit=100,但针对单主机的 limit_per_host 默认是 0(不限制)。由于挂载隧道代理时,客户端的所有请求在 TCP 层面都打向同一个网关域名,必须确保 limit 放开的同时把 limit_per_host 保持为 0,否则网关入口就会变成人工限流阀。
第三层则是 HTTP/2 多路复用在隧道代理上的“认知误区”。很多人选 httpx 是看中了 http2=True,认为多路复用能减少握手耗时。可说白了,走 HTTP CONNECT 隧道代理访问 HTTPS 目标站时,如果你使用的是按请求轮换 IP 的出口策略,客户端一旦复用同一条 HTTP/2 长连接,所有并发请求就会全部命中同一个出口 IP,直接触发目标站风控;而如果你为了换 IP 强制关闭连接,HTTP/2 多路复用的收益不仅归零,初始化 h2 帧状态机的额外 CPU 消耗反而成了纯粹的负资产。
四、核心压测与生产接入代码对照
下面两段核心代码分别展示了 aiohttp 与 httpx 在 200 并发隧道代理场景下的标准生产配置。注意 aiohttp 中 TCPConnector 的网关连接放开与 enable_cleanup_closed=True(防止 SSL 异常断开后文件描述符悬挂)。
import asyncio
import time
import aiohttp
PROXY_URL = "http://TUNNEL_USER:TUNNEL_PASS@tn.16yun.cn:9020"
TARGET_URL = "https://httpbin.org/ip"
CONCURRENCY = 200
TOTAL_REQUESTS = 2000
async def fetch_aiohttp(session: aiohttp.ClientSession, sem: asyncio.Semaphore) -> bool:
async with sem:
try:
async with session.get(
TARGET_URL,
proxy=PROXY_URL,
timeout=aiohttp.ClientTimeout(total=12),
) as resp:
await resp.read()
return resp.status == 200
except (aiohttp.ClientError, asyncio.TimeoutError):
return False
async def run_aiohttp() -> None:
connector = aiohttp.TCPConnector(
limit=CONCURRENCY,
limit_per_host=0,
ttl_dns_cache=300,
enable_cleanup_closed=True,
)
sem = asyncio.Semaphore(CONCURRENCY)
start = time.perf_counter()
async with aiohttp.ClientSession(connector=connector) as session:
results = await asyncio.gather(
*[fetch_aiohttp(session, sem) for _ in range(TOTAL_REQUESTS)]
)
elapsed = time.perf_counter() - start
ok = sum(results)
print(f"[aiohttp] 成功: {ok}/{TOTAL_REQUESTS}, 耗时: {elapsed:.2f}s, QPS: {ok / elapsed:.1f}")
if __name__ == "__main__":
asyncio.run(run_aiohttp())
若团队决定选用 httpx,则必须通过 httpx.Limits 显式对齐连接池容量,避免并发越高、排队越久的假并发状态:
import asyncio
import time
import httpx
PROXY_URL = "http://TUNNEL_USER:TUNNEL_PASS@tn.16yun.cn:9020"
TARGET_URL = "https://httpbin.org/ip"
CONCURRENCY = 200
TOTAL_REQUESTS = 2000
async def fetch_httpx(client: httpx.AsyncClient, sem: asyncio.Semaphore) -> bool:
async with sem:
try:
resp = await client.get(TARGET_URL)
return resp.status_code == 200
except httpx.HTTPError:
return False
async def run_httpx() -> None:
limits = httpx.Limits(
max_connections=CONCURRENCY,
max_keepalive_connections=50,
keepalive_expiry=30.0,
)
sem = asyncio.Semaphore(CONCURRENCY)
start = time.perf_counter()
async with httpx.AsyncClient(
proxy=PROXY_URL,
limits=limits,
timeout=httpx.Timeout(12.0),
) as client:
results = await asyncio.gather(
*[fetch_httpx(client, sem) for _ in range(TOTAL_REQUESTS)]
)
elapsed = time.perf_counter() - start
ok = sum(results)
print(f"[httpx] 成功: {ok}/{TOTAL_REQUESTS}, 耗时: {elapsed:.2f}s, QPS: {ok / elapsed:.1f}")
if __name__ == "__main__":
asyncio.run(run_httpx())
五、生产环境上量前的两个工程细节
第一是代理连接复用与 IP 轮换的博弈。如果上游网关采用“按每次新连接分配出口 IP”的机制,在 aiohttp 或 httpx 中开启长时间的 keepalive 会导致连续请求复用同一条隧道出口。工程上可以在请求头显式携带 Connection: close,或者在需要切换身份的周期内主动重建连接,用可控的握手成本换取出口 IP 的高分散度。
第二是操作系统文件描述符(FD)上限。单机跑 200 到 500 并发外加短连接模式时,Linux 默认的 ulimit -n 1024 极易被瞬间打穿并抛出 Too many open files。生产容器或宿主机上线前务必将 nofile 调高至 65535 以上,同时严禁在每次任务中反复实例化新的 ClientSession。
总结与架构权衡
技术选型没有银弹,经验上有个粗略规律可以直接对号入座。
并发量低于 30 且脚本里夹杂大量同步阻塞模块时,继续用 requests.Session 配合 HTTPAdapter 连接池和适度线程池,维护成本最低,出问题最好查。并发在 50 到 150 之间,希望平滑过渡异步代码或目标站强制校检 HTTP/2 特征时,选 httpx 并调大 Limits 参数是最舒服的方案。如果单机需要稳定扛住 200 以上的代理高并发,把每一分 CPU 和内存都榨出有效吞吐,aiohttp 配合 uvloop 加上稳定的云端隧道代理底座,依然是目前 Python 采集工程里最硬核的选择。