别再无脑开 1000 个协程了:为什么你的 Python 异步爬虫越跑越慢

简介: Python异步爬虫新手常误以为协程越“多”越好,盲目并发1000+导致QPS断崖下跌、CPU飙高、超时刷屏。本文揭示四大性能杀手:事件循环单线程饱和、连接池握手风暴、代理网关限流、GC停顿,并给出基于信号量控流+隧道代理的工业级实践方案。(239字)

很多刚接触 Python 异步爬虫的同行,都会经历一个“协程暴兵”的狂热期。

在教程里看完 asyncio 和 aiohttp,发现每个协程只占几 KB 内存,比动辄几 MB 栈空间的系统线程轻量上千倍。于是不少人顺理成章地得出一个结论:既然协程这么轻,那我就开 500 个、1000 个甚至 2000 个,直接用 asyncio.gather(*[fetch(url) for url in urls]) 一把全推上去,抓取速度岂不是起飞?

然而现实往往会给所有人上一课。
当你把并发协程数从 10、50 一路上调到 500、1000 时,系统的表现不仅没有线性翻倍,反而大概率会演变成一场灾难:实际有效 QPS 在达到某个峰值后断崖式下跌,客户端 CPU 占用率直接顶到 100%,响应耗时从原来的 200 毫秒飙升到 10 秒以上,控制台更是被 ClientTimeout、ServerDisconnectedError 和一堆 429 报错直接刷屏。

先说结论,再说为什么:
在异步 I/O 体系中,“并发”绝不等于“吞吐”。协程本身虽然开销极低,但它包裹的网络 I/O 调度、数据解析、操作系统的文件描述符管理,以及代理服务器的排队机制,全都有极其严苛的物理上限。

当你在单线程事件循环里无节制地塞入 1000 个协程时,你其实亲手制造了事件循环单线程饱和、连接池握手风暴、上游代理链路拥堵与内存 GC 停顿四大死锁。

今天这篇文章,我结合我们团队在实际生产项目中的真实压测数据,往下拆一层把性能崩盘的深层机制讲透,并给出一份基于隧道代理的工业级控流实践代码。

一、真实压测:从 10 到 1000 协程的性能崩盘曲线

去年我们团队承接了一个全网新闻动态的监测系统,当时在配置为 8 核 CPU、16G 内存的云主机上,使用 Python 3.10 + aiohttp 配合隧道代理做高频请求测试。

目标是抓取一批常规接口(响应体积约 15KB,上游服务端平均响应延迟约 150ms)。我们对比了不同并发协程数下的真实表现:

并发协程数 实际有效 QPS 请求平均耗时 (P50) 请求尾部耗时 (P95) 成功率 客户端 CPU 占用 瓶颈表现
10 约 58 165ms 220ms 99.8% 8% 算力与带宽严重闲置
50 约 260 185ms 280ms 99.5% 22% 黄金甜点区,吞吐极高
100 约 420 230ms 410ms 98.2% 38% 吞吐见顶,轻微排队
200 约 390 480ms 1100ms 94.1% 65% 耗时明显拉长,偶发超时
500 约 180 2600ms 6800ms 78.5% 92% QPS 腰斩,大面积连接超时
1000 约 75 7800ms 14500ms 41.2% 100% 事件循环卡死,崩溃

数据摆在眼前:从 50 到 100 协程,是整套系统的效率甜蜜区(Sweet Spot);而一旦越过 200 协程,随着协程数往 1000 冲,有效 QPS 不升反降,最后跌得比 10 个协程时还要惨,成功率直接腰斩。

性能并没有随着并发数线性提高,反而在 1000 个协程时彻底崩盘。这背后究竟发生了什么?

二、从 10 到 1000 协程:幕后的四大性能杀手

往下拆一层看,协程数从 10 飙到 1000 时,系统的瓶颈根本不在“协程对象占了多少内存”,而在以下四个相互交织的深层陷阱。

1. 事件循环单线程饱和与回调饥饿(Event Loop Starvation)

这是最多爬虫工程师踩坑的地方。很多人误以为 asyncio 是多线程或者能自动利用多核,其实不然。

Python 的 asyncio 事件循环本质上是单进程、单线程在跑一个无限 while 循环。

在网络等待(I/O 等待)期间,协程主动让出控制权,确实不占 CPU。但是,一旦数据包到达网卡、I/O 准备就绪,后面的事情全部是 CPU 密集的同步代码:TLS/SSL 协议解密握手、HTTP 协议头解析、gzip/brotli 数据解压缩,以及 JSON 序列化反序列化或 HTML 文本解码。

当你开 1000 个协程时,只要网络稍微抖动后集中返回,几百个 socket 的就绪事件会同一瞬间涌入事件循环。单线程的事件循环必须排队处理这几百个回调。当 CPU 忙着去解密和解析前 100 个请求的数据时,后面 900 个协程虽然网络层早就到货了,但只能在事件循环队列里排队干等。

此时你在应用层测到的“响应耗时”,包含了大量的本地 CPU 排队等待耗时。很多请求就是这样在客户端自己的队列里活活排队排到超时(ClientTimeout)的。

2. 连接池握手风暴与本地端口耗尽

HTTP 请求不是凭空发生的,底层依赖操作系统的 TCP 套接字(Socket)。

如果你没有对底层连接器做限制,直接 asyncio.gather 扔进 1000 个协程,系统会在几毫秒内向操作系统申请 1000 个新 Socket,并发起 1000 次 TCP 三次握手和 TLS 握手。这不仅会瞬间打满本地的可用临时端口(Ephemeral Ports),还会引发操作系统的文件描述符(ulimit -n)上限告警。

与此同时,大规模采集通常需要频繁更换出口 IP,很多请求采用短连接模式。短时间内成百上千个短连接密集关闭,会导致操作系统网络栈堆积海量的 TIME_WAIT 状态连接,新的套接字根本申请不下来,直接抛出 Cannot assign requested address。

3. 上游网关防御与隧道代理排队(流量非无限)

很多爬虫研发在写代码时,习惯性把代理网络假设成一个“无限吞吐的理想黑盒”。但现实中,无论是目标网站的 WAF,还是中间的商业代理服务,都有严密的容量与流控限制。

以工业级隧道代理为例,代理服务器的底层原理是在云端网关维护一组高匿出口调度池。客户端发起 1000 个并发请求,相当于把 1000 路 TCP 链接直接砸向代理网关。代理服务器的上行带宽、连接数、TLS 握手解密算力瞬间达到峰值。代理网关为了自保,必然触发限流机制(例如返回 429 限流或主动断开排队过深的连接)。即使代理网关顶得住,目标网站的防 CC 策略看到同一个网关在几毫秒内倾泻上千次请求,也会直接拉起 403 阻断或返回滑动验证码。原本顺畅的 200 响应,在暴增的并发下变成了重试、降级和排队,有效吞吐自然大跌。

4. 内存对象暴增与 Python GC 停顿

在 1000 个协程同时激活的状态下,内存中同时驻留着 1000 个 Request 上下文、1000 块 TCP 接收缓冲区,以及待解析的大块字节流。单进程堆内存快速从几十 MB 膨胀到 1GB 以上。这种短期生命周期对象的暴增,会高频触发 Python 垃圾回收机制(GC)的第 1 代和第 2 代全量扫描。

Python 的垃圾回收存在 Stop-The-World 特征,GC 停顿期间整个事件循环彻底冻结。而一旦事件循环冻结十几毫秒,对于毫秒级的网络 I/O 而言就是灾难性的抖动。

三、工业级破局方案:信号量控流与隧道代理实战

要想真正发挥异步的高吞吐优势,核心逻辑不是“放飞协程”,而是做精细化的入水阀门控制。

工业级异步爬虫的黄金法则是:限制在途请求数(In-flight Requests),让并发数量稳定在系统的甜蜜区,同时利用复用连接池平滑网络抖动。

核心调优思路主要有三点:
其一,使用 asyncio.Semaphore 限制在途并发。无论任务队列里有 1 万条还是 100 万条 URL,严格限制同时处于网络传输中的请求数在 50 到 100 之间。
其二,微调连接池容量与超时策略。设置 aiohttp.TCPConnector(limit=100, limit_per_host=30),复用底层 TCP 连接,避免短连接风暴。
其三,结合高质量商业隧道代理(以隧道代理为例)。使用固定入口网关(t.16yun.cn:31111),由云端自动在海量 IP 池中轮换出口,客户端无需自建和轮询庞大且不稳定的本地 IP 池,只需要把精力放在采集与数据处理上。

以下是一份可以直接在生产环境中参考并使用的标准工程 Demo:

# -*- coding: utf-8 -*-
"""
高并发异步爬虫控流与隧道代理标准实践
核心技术:asyncio.Semaphore + aiohttp 连接池调优 + 亿牛云隧道代理集成
"""

import asyncio
import time
import aiohttp

# 爬虫代理(隧道版)配置
# 固定入口网关与端口,支持用户名密码认证,云端自动调度数十万高匿出口 IP
PROXY_HOST = "t.16yun.cn"
PROXY_PORT = "31111"
PROXY_USER = "16YUN_USER_SAMPLE"
PROXY_PASS = "16YUN_PASS_SAMPLE"
PROXY_URL = f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}"

# 并发控制黄金参数:根据实测基线,推荐单实例在途并发控制在 50~100 之间
MAX_CONCURRENCY = 60       # 最大在途请求数(通过 Semaphore 控制)
CONNECTOR_LIMIT = 100      # aiohttp 底层连接池最大连接数
REQUEST_TIMEOUT = 12       # 单请求超时时间(秒)


class RobustAsyncSpider:
    """工业级异步爬虫客户端,具备信号量流控与连接池管理能力"""

    def __init__(self, proxy_url: str, max_concurrency: int):
        self.proxy_url = proxy_url
        self.semaphore = asyncio.Semaphore(max_concurrency)
        self.session = None

    async def init_session(self):
        """初始化 aiohttp ClientSession,调优底层 TCP 连接池与 DNS 缓存策略"""
        timeout = aiohttp.ClientTimeout(
            total=REQUEST_TIMEOUT,
            connect=4.0,       # 建立连接阶段最长等待 4 秒,防止挂死
            sock_read=8.0      # 读取数据阶段最长等待 8 秒
        )

        connector = aiohttp.TCPConnector(
            limit=CONNECTOR_LIMIT,        # 全局最大连接池
            limit_per_host=20,            # 单域名最大并发连接数,避免打崩目标源站
            ttl_dns_cache=300,            # 缓存 DNS 解析结果 5 分钟,降低高频解析开销
            enable_cleanup_closed=True,   # 及时清理处于关闭状态的 Socket
            ssl=False                     # 按需关闭 SSL 强校验以提升吞吐
        )

        self.session = aiohttp.ClientSession(
            connector=connector,
            timeout=timeout
        )

    async def fetch(self, url: str, retry_count: int = 2) -> dict:
        """单次抓取逻辑:通过信号量精细限流,并在异常时执行受控重试"""
        headers = {
   
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
            "Accept-Encoding": "gzip, deflate",
            "Connection": "keep-alive"
        }

        # 核心:使用信号量排队,确保当前在途并发严格不超过 MAX_CONCURRENCY
        async with self.semaphore:
            for attempt in range(retry_count + 1):
                start_time = time.perf_counter()
                try:
                    # 挂载隧道代理,由网关在云端动态分发出口 IP
                    async with self.session.get(url, proxy=self.proxy_url, headers=headers) as resp:
                        latency_ms = round((time.perf_counter() - start_time) * 1000, 1)
                        status = resp.status

                        if status == 200:
                            content = await resp.text(errors='ignore')
                            # 业务成功,返回标准度量指标
                            return {
   
                                "url": url,
                                "status": 200,
                                "latency_ms": latency_ms,
                                "content_size": len(content),
                                "success": True
                            }
                        elif status in (429, 503):
                            # 上游告警或被限流,稍作休眠等待重试
                            await asyncio.sleep(0.5 * (attempt + 1))
                            continue
                        else:
                            return {
   
                                "url": url,
                                "status": status,
                                "latency_ms": latency_ms,
                                "success": False,
                                "error": f"http_status_{status}"
                            }

                except asyncio.TimeoutError:
                    if attempt == retry_count:
                        return {
   "url": url, "status": 504, "latency_ms": REQUEST_TIMEOUT * 1000, "success": False, "error": "timeout"}
                    await asyncio.sleep(0.3)
                except Exception as e:
                    if attempt == retry_count:
                        return {
   "url": url, "status": 500, "latency_ms": 0, "success": False, "error": str(type(e).__name__)}
                    await asyncio.sleep(0.3)

    async def close(self):
        """释放底层网络资源"""
        if self.session and not self.session.closed:
            await self.session.close()


async def main():
    spider = RobustAsyncSpider(proxy_url=PROXY_URL, max_concurrency=MAX_CONCURRENCY)
    await spider.init_session()

    # 模拟构造 300 个待抓取任务(即使有上万个任务,也会通过 Semaphore 平滑消费)
    target_urls = [
        f"https://httpbin.org/get?item_id={i}" for i in range(300)
    ]

    print(f"[*] 开始高并发抓取测试,在途并发上限设定为: {MAX_CONCURRENCY} ...")
    start_total = time.perf_counter()

    # 优雅消费:使用 asyncio.gather 提交所有任务,但底层严格按信号量节奏执行
    tasks = [spider.fetch(url) for url in target_urls]
    results = await asyncio.gather(*tasks)

    total_time = round(time.perf_counter() - start_total, 2)
    success_count = sum(1 for r in results if r and r.get("success"))
    avg_latency = round(sum(r.get("latency_ms", 0) for r in results) / len(results), 1)

    print("\n" + "=" * 45)
    print(f"测试完成!")
    print(f"总请求任务数: {len(target_urls)}")
    print(f"成功请求数:   {success_count} (成功率: {round(success_count / len(target_urls) * 100, 2)}%)")
    print(f"总耗时:       {total_time} 秒")
    print(f"实际平均 QPS: {round(len(target_urls) / total_time, 1)}")
    print(f"平均单次耗时: {avg_latency} 毫秒")
    print("=" * 45)

    await spider.close()

if __name__ == '__main__':
    asyncio.run(main())

四、生产环境调优的避坑法则

结合我们团队踩过的坑,在落地大规模异步爬虫时,建议遵循以下工程经验:

第一,单进程不要贪多,靠多进程拓展算力。既然 Python 的事件循环是单线程运行的,单进程的在途并发通常压在 50 到 80 最为健康。如果你有一台 8 核 16G 或者 16 核 32G 的机器,千万别在一个进程里开 800 个协程;正确的做法是启动 4 到 8 个 Worker 进程(比如用 Celery、RQ 或简单的 multiprocessing),每个进程内部管理 50 个协程。这样既能绕过单线程事件循环的 CPU 瓶颈,又能把整台机器的多核算力完全吃满。

第二,警惕同步阻塞库混入异步流程。异步代码里只要出现一个 time.sleep()、同步的 requests.get()、或者一个耗时 200 毫秒的纯 CPU 正则匹配,整个事件循环内的所有协程都会在这 200 毫秒内彻底停滞。必须确保所有网络 I/O 走异步库,CPU 密集型清洗逻辑移到子进程执行。

第三,给代理预留网络缓冲。商业隧道代理虽然底层拥有几十万动态 IP 池,但外部代理连接本质上也是跨机房的网络请求。通过控制并发节奏,配合轻量级的重试退避机制,能显著提高高风控站点的通过率。

这块怎么权衡,得看你们自己的业务量级。不要迷信成百上千协程的“虚假繁荣”,把在途并发收拢在甜蜜区,系统才能长期稳定、高吞吐地跑下去。

相关文章
|
1月前
|
人工智能 安全 API
MCP 是 API 的下一层?先搞清楚它到底解决什么问题
MCP 是 API 的下一层吗?本文讲清 MCP 解决的 N×M 集成问题、与 API 的本质区别、适用场景和当前已知风险,给 API 服务商一个冷静的接入建议。
401 1
|
2月前
|
存储 人工智能 自然语言处理
阿里云千问办公QwenWork指南:产品核心能力、费用价格、使用场景及问题解答,一文看懂!
阿里云千问办公QwenWork是面向办公场景的AI智能体,支持自然语言一句话生成PPT、分析财报、搭建网页等,深度集成钉钉,覆盖文档、会议、审批、多模态理解与全栈网页交付等六大能力。提供免费版及个人/企业付费版,开箱即用,真正实现“说句话就干活”。
|
1月前
|
关系型数据库 MySQL 数据库
【全网最详细】WordPress建站教程:WordPress下载、安装和建站一篇搞定
WordPress是免费开源建站系统,零代码即可搭建博客、企业站等。内置文章、页面、用户管理等功能,主题插件丰富,中文支持完善。支持Windows/macOS/Linux,可本地练习或服务器上线,安装配置全程图文实测指导。(239字)
|
2月前
|
人工智能 SEO
企业官网GEO优化进阶:AI搜索可见性的诊断与度量方法
本文面向已完成GEO基础配置的企业官网,讲解AI搜索可见性的诊断与度量方法:检索基线测试、引用来源归因、核心指标看板与内容整改闭环,帮助运营者量化GEO投入产出,持续提升品牌在AI回答中的可见度。
|
10月前
|
弹性计算 安全 Linux
阿里云服务器镜像解析:公共、自定义、共享、云市场及社区镜像对比与选择参考
阿里云服务器ESC镜像包括公共、自定义、共享、云市场及社区五大类型,每种镜像具有不同的特性和适用场景。公共镜像安全稳定;自定义镜像量身定制,可快速部署;共享镜像可跨账号协作;云市场镜像一键部署,省时省心;社区镜像开放共享,满足个性化需求。选择镜像时,用户需考虑操作系统、初始配置、安全性、稳定性及成本。
|
7月前
|
缓存 监控 NoSQL
数据接口的容错设计:如何应对行情日本API的常见故障
不要等到用户投诉才发现问题。定期(例如每分钟)调用一个轻量级的健康检查接口,如果连续失败多次,立即发送告警(邮件、短信、钉钉)。在阿里云上,可以使用云监控(CloudMonitor)配置对日本API的探测任务。jkidata.com 提供了一个公共状态页,你可以直接监控日本API的实时状态。
|
开发框架 .NET C#
VSCode开发.net项目时调试无效
【9月更文挑战第22天】在使用 VSCode 开发 .NET 项目时遇到调试问题,可从项目配置、调试配置、调试器安装、运行环境、日志和错误信息等方面排查。确认项目类型及文件配置,检查 `launch.json` 文件及配置项,确保调试器扩展已安装并启用,验证 .NET 运行时版本和环境变量,查看 VSCode 输出窗口和项目日志文件,检查权限及代码错误。若问题仍未解决,可查阅官方文档或社区论坛。
1209 5
EMQ
|
JSON Linux 网络性能优化
MQTT 5.0 报文解析 02:PUBLISH 与 PUBACK
本文将介绍在 MQTT 中用于传递应用消息的 PUBLISH 报文以及它的响应报文。不管是客户端向服务端发布消息,还是服务端向订阅端转发消息,都需要使用 PUBLISH 报文。决定消息流向的主题、消息的实际内容和 QoS 等级,都包含在 PUBLISH 报文中。
EMQ
1466 127
MQTT 5.0 报文解析 02:PUBLISH 与 PUBACK
|
人工智能 监控 API
全网跪求的抢票神器!用 CodeBuddy 联动魔搭 MCP,我把 12306 抢票系统玩明白了
CodeBuddy 作为智能编程领域的佼佼者,无需用户具备深厚的编程知识,就能依据用户需求迅速生成高效代码。在票务信息获取方面,它巧妙地构建起与两款 MCP 顺畅交互的桥梁。通过简洁直观的指令输入,CodeBuddy 将用户对票务信息的需求精准转化为机器可理解的语言,为后续获取信息的流程奠定坚实基础。
1301 2
|
人工智能 Java 程序员
一文彻底搞定电阻元件
电阻元件是限流器件,通过其电流与两端电压成正比(V=IR),阻值受温度、材料等影响。按特性分为线性与非线性,材料上有碳膜、金属膜等,用途涵盖限流、分压、偏置、滤波等。标称阻值有允许偏差,额定功率和最高工作电压需注意。色标法和直接读取法可用于识别阻值,万用表测量时需关闭电源并选择合适量程。电阻在电路设计中不可或缺,掌握其特性和应用对电子工程师至关重要。
1585 0
一文彻底搞定电阻元件

热门文章

最新文章