Python爬虫高并发选型实测:aiohttp、httpx与requests挂代理谁更快?

0 阅读8分钟

很多爬虫团队在架构升级时,都有过一个看似稳妥的决定:业务早期的 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 时,实测大盘呈现出截然不同的走势:

客户端方案并发数有效 QPSP95 延迟进程峰值内存单核 CPU 峰值占用
requests + 线程池100118 req/s1.12s168 MB64%
httpx (AsyncClient)100152 req/s0.89s74 MB78%
aiohttp (ClientSession)100235 req/s0.56s52 MB41%
requests + 线程池200146 req/s1.85s312 MB92%
httpx (AsyncClient)200198 req/s1.34s108 MB96%
aiohttp (ClientSession)200342 req/s0.72s68 MB58%

这里有两个很值得注意的信号。

其一,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 采集工程里最硬核的选择。