Spider-第12讲-asyncio异步并发爬取

第 12 讲 · asyncio 异步并发:把「等网络」的时间重叠起来

本讲目标 :把串行爬虫的「等待」,用 asyncio + aiohttp 重叠起来。

讲清串行 vs 并发的真实差距、Semaphore 怎么管并发上限、以及三个新手必踩的坑。

配套代码 :spiders/s12_async_scrape.py

运行 :python spiders/s12_async_scrape.py

本讲产物 :data/output/s12_books_async.csv(并发抓 10 页、去重后 48 条)

---下载地址:git clone https://gitee.com/wuyikui555/python-spider.git

一、先看清「等」有多贵

先问一个问题:一个爬虫 90% 的时间在干什么?

答案是「等」------等 TCP 握手、等服务器算完、等数据回来。

串行爬虫是这样干的:

复制代码
发请求 A ──等待── 收数据
                  发请求 B ──等待── 收数据
100 个请求 = 所有等待时间加起来,期间你的 CPU 一直在摸鱼。

并发的思路是:发请求 A 之后不等它,立刻发 B、C、D......谁先回来就先处理谁。

复制代码
100 个请求的总耗时 ≈ 最慢的那一个,而不是所有耗时之和。

为了看清差距,脚本里加了一个「慢接口」靶场 /api/slow?ms=150------每个请求固定耗时 150ms。为什么要刻意造慢?因为本地回环一个请求只要 1ms,不加延迟,并发的优势会被噪声吃掉。

python 复制代码
# 串行版本(对照组)
def fetch_slow_sync(base_url: str, n: int) -> None:
    with HttpClient(base_url=base_url, timeout=30) as client:
        for _ in range(n):
            client.get(f"/slow?ms={SLOW_MS}")
python 复制代码
# 并发版本
async def fetch_slow_many(base_url: str, n: int, concurrency: int) -> list[dict]:
    sem = asyncio.Semaphore(concurrency)
    timeout = aiohttp.ClientTimeout(total=30, connect=5)
    url = f"{base_url}/slow?ms={SLOW_MS}"
    async with aiohttp.ClientSession(headers=HEADERS, timeout=timeout) as session:
        tasks = [get_json(session, url, sem) for _ in range(n)]
        return list(await asyncio.gather(*tasks))

实测输出:

复制代码
  串行 (requests)                1.94s       6.2 请求/秒
  并发 (aiohttp)                 0.68s      17.6 请求/秒

★ 提速 2.9 倍。注意:快不是因为「CPU 更努力」,
  而是「等待被重叠了」。理论极限就是 12 倍(全重叠)------
  实际差一点,因为发请求、收数据这些动作仍然要排队。

12 个请求、每个 150ms:

方式 总耗时 速率 怎么解释
串行 1.94s 6.2 请求/秒 ≈ 12 × 150ms 全加起来
并发 0.68s 17.6 请求/秒 ≈ 一个 150ms 的量级 + 排队开销

为什么不是 12 倍(理论极限),而是 2.9 倍? 因为并发不是魔法。150ms 里,真正「纯等待」的部分被重叠了,但每个请求的「发出」和「收下」仍然要在事件循环里排队。并发度=12 时,12 个请求同时出发,服务器(哪怕它是本地的)也要逐个处理。重叠的是等待,不是计算。


二、并发度不是越大越好:Semaphore 在管什么

fetch_slow_many 里那个 concurrency 参数,控制的是「同一时刻最多几个请求在飞」。它的实现是一个信号量:

python 复制代码
async def get_json(session, url, sem):
    async with sem:                     # 拿到名额才发请求,没名额就 await 等待
        async with session.get(url) as resp:
            resp.raise_for_status()
            return await resp.json()

换不同并发度各跑一次:

python 复制代码
for conc in (1, 4, N_TASK):
    with LocalSite() as site:
        t0 = time.time()
        asyncio.run(fetch_slow_many(site.base_url, N_TASK, concurrency=conc))
        dt = time.time() - t0
    bench(f"并发度 {conc:>2}", dt, N_TASK)

实测输出:

复制代码
  并发度  1                       1.89s       6.4 请求/秒
  并发度  4                       0.50s      23.9 请求/秒
  并发度 12                       0.67s      17.9 请求/秒

这个结果很有意思,值得逐行看:

并发度 耗时 说明
1 1.89s 退化成串行,≈ 12 × 150ms
4 0.50s 12 ÷ 4 = 3 轮 × 150ms = 450ms,最快
12 0.67s 一次全放出去,反而比并发度 4 慢

注意最后一行:并发度 12 比并发度 4 还慢。 这不是测错了,而是真实规律:

复制代码
★ 并发度 1:退化成串行(还有事件循环的开销,甚至更慢)。
  并发度 = 任务数:一次全放出去,最快,但也最容易被风控盯上。
  真实项目经验值 5~20:拿到大部分收益,又不至于把人打挂。
  • 并发度 1:退化成串行,还多背了事件循环的开销;
  • 并发度 4:恰好把等待叠满,又没有过度争抢,最快;
  • 并发度 12:12 个协程同时抢事件循环、抢 socket,调度和排队反而拖慢了总时间。

「并发度」不是越大越好。 它存在一个甜点区:任务能被充分重叠,但又没到互相打架的程度。真实项目的经验值是 5~20。

Semaphore 到底在管什么

asyncio.Semaphore(n) 就是 n 个名额:async with sem 时若还有名额就拿走一个(立刻继续),没有就 await 挂起,直到别人把名额还回来。

python 复制代码
sem = asyncio.Semaphore(concurrency)   # ← 并发上限

为什么必须限? 因为不限的话,你 for _ in range(10000) 会瞬间创建 1 万个协程,一股脑砸向服务器。

那不叫爬虫,叫压测/攻击。对方轻则一堆 429,重则直接封你 IP。

Semaphore 就是你给自己踩的刹车。异步让「写并发」变得极其便宜------asyncio.gather(*tasks) 一行搞定------但也正因为太便宜,你更容易一不小心把并发开到失控。限流那条线(第 11 讲)和并发上限(本节)是配套的:一个管「多快」,一个管「多宽」。


三、拿真实数据:并发抓 10 页、去重后落盘

前面都在打慢接口做基准测试。现在打真实接口------靶场有 5 页分页,每页 10 条,脚本并发抓 10 页(故意多抓,看过界行为):

python 复制代码
async def fetch_pages(base_url: str, pages: list[int], concurrency: int) -> list[dict]:
    sem = asyncio.Semaphore(concurrency)
    timeout = aiohttp.ClientTimeout(total=15, connect=5)
    async with aiohttp.ClientSession(headers=HEADERS, timeout=timeout) as session:
        tasks = [get_json(session, f"{base_url}/api/books?page={p}&size=10", sem)
                 for p in pages]
        payloads = await asyncio.gather(*tasks)
    rows: list[dict] = []
    for payload in payloads:
        rows.extend(payload["data"]["list"])
    return rows

实测输出:

复制代码
  并发抓 10 页,用时 0.52s
  原始 48 条 → 按 id 去重 48 条
  已写入:s12_books_async.csv(2655 字节)

这里有个值得注意的数字:抓了 10 页,原始却只有 48 条。因为靶场总共 48 本书、5 页,第 6~10 页返回空列表------所以「原始 48 条」本身就是去重前的结果。

真正的去重逻辑在这里:

python 复制代码
seen: dict[int, dict] = {}
for r in raw:
    seen[r["id"]] = r                               # 用主键做键,天然去重
rows = sorted(seen.values(), key=lambda x: x["id"])

用「主键做字典的键」是最省事的去重方式 ------同一个 id 后覆盖前,顺带还解决了「同一页被抓两次」的问题。asyncio.gather 返回的是按传入顺序 的结果,不是按完成顺序,所以这里顺序其实是稳的;但显式 sorted 一遍更保险,也让文件内容可复现。

asyncio.gather 的一个关键特性

python 复制代码
tasks = [get_json(...) for _ in range(n)]
return list(await asyncio.gather(*tasks))

gather 返回的结果,顺序和你传进去的 tasks 一一对应 ------哪怕第 5 个请求最先返回,它也在结果列表的第 5 位。这一点和「按完成顺序处理」的 as_completed 不同:

方法 结果顺序 适合
gather 按传入顺序 结果要和输入对应(如按页拼数据)
as_completed 按完成顺序 「谁先回来先处理谁」,做进度条

四、三个新手必踩的坑

复制代码
  1. asyncio.run() 只能在最外层调用一次。
     在 Jupyter / 已运行的事件循环里要用 await,再套 run 会直接报错:
     RuntimeError: asyncio.run() cannot be called from a running event loop
  2. aiohttp 的 ClientSession 一定要 with 起来(或用完 await session.close())。
     每次请求新建一个 session = 每次重建连接池,可能比串行还慢。
  3. 忘了限流。并发 1000 跑一会儿,大概率换来一堆 429 / 直接封 IP。
     「快」是要付代价的,Semaphore 就是你给自己踩的刹车。

坑一:asyncio.run() 的位置

asyncio.run() 的职责是「开一个新的事件循环、跑完、关掉」。所以它只能在最外层调一次 。如果你在 Jupyter 里、或者已经在一个 async def 里又调 asyncio.run(),会直接抛:

复制代码
RuntimeError: asyncio.run() cannot be called from a running event loop

正确姿势是在当前协程里 await:

python 复制代码
# 在已有事件循环里(Jupyter / async 函数内)
rows = await fetch_pages(base_url, pages, concurrency=10)   # 不要写 asyncio.run(...)

本工程的 main() 是同步函数,所以每次 asyncio.run(...) 都是「开一个循环跑一段」------这是合法的最外层用法。

坑二:ClientSession 必须复用

python 复制代码
async with aiohttp.ClientSession(headers=HEADERS, timeout=timeout) as session:
    ...

ClientSession 内部维护着连接池,复用连接、共享 Cookie、共享超时配置。如果你图省事,每个请求里新建一个 session:

python 复制代码
# 反面教材
async def bad(url):
    async with aiohttp.ClientSession() as s:     # 每个请求都重开连接池
        async with s.get(url) as r:
            return await r.json()

那每次请求都要重新握手、重新建池,开销可能比串行还大 。记住:一个任务一整批请求,共用一个 session ------就像第 4 讲里 requests.Session 的道理一样。

坑三:异步里别塞阻塞调用

这是最隐蔽的坑。asyncio 是单线程 的:所有协程在一个线程里轮流跑。只要有一个协程执行了「阻塞」的代码,整个事件循环都会被卡住,其它协程全部陪等。

常见的「阻塞刺客」:

写法 问题 怎么办
time.sleep(1) 阻塞整个事件循环 await asyncio.sleep(1)
requests.get(url) 同步 HTTP,阻塞 用 aiohttp(别混用 requests)
大量计算 / 大文件读写 CPU 或 IO 阻塞 await loop.run_in_executor(...)
同步的数据库驱动 阻塞 用异步驱动,或丢线程池

记住一句话:在 async def 里,任何没有 await 的耗时操作,都会冻结整个爬虫。 第 11 讲的 HttpClient(基于 requests)是同步的,所以本讲打并发用的是 aiohttp------两套东西不要混在一个协程里。

换成真实站点时要注意什么

  • UA 得自己写。 aiohttp 不像 requests 会自动选 UA,HEADERS 里必须带:

    python 复制代码
    HEADERS = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) ... Chrome/124.0.0.0 Safari/537.36",
        "Accept-Language": "zh-CN,zh;q=0.9",
    }

    不写 UA 的异步爬虫,等于举着牌子告诉服务器「我是脚本」。

  • 超时用 ClientTimeout。 aiohttp.ClientTimeout(total=30, connect=5) 对应第 4 讲的 (5, 30) 元组------建连 5s、总时长 30s,别忘了它必须挂在 ClientSession 上。

  • 并发度从小往大调。 先 5,确认目标站受得了,再往上试。别一上来就 100。

  • 429 要当回事。 aiohttp 不会自动重试 429(不像第 4 讲的 HttpClient)。真实项目里要自己包一层重试 + 退避。


本讲小结

能力 一句话要点
异步的本质 不是「更快地算」,是「更聪明地等」;重叠的是等待,不是 CPU
提速上限 理论上限 = 任务数(全重叠);实际受排队影响,达不到
Semaphore 控制「同时几个请求在飞」;不限流 = 压测,会被封
甜点区 并发度不是越大越好,经验值 5~20;过大反而变慢
asyncio.gather 按传入顺序收集结果;要「谁先回来先处理」用 as_completed
asyncio.run 只能在最外层调一次;事件循环里要用 await
ClientSession 必须复用;每个请求新建 = 每次重建连接池,可能比串行还慢
阻塞调用 async def 里任何没 await 的耗时操作都会冻结整个循环
去重 用主键做字典的键,天然去重,还能合并多页结果

下一讲

到这里,「抓 → 解析 → 存 → 工程化 → 并发」这条主线就闭环了。

但我们的爬虫一直只在做一件事:读。它把别人的数据拿回来,却没有往回送过任何东西。

下一讲换个方向------从「只读」变成「会写」。用 POST 把整理好的数据自动提交给别人的系统:

登录拿 Cookie、带着会话提交表单、处理 CSRF token、看接口是怎么回你的。

你会第一次体会到:爬虫不只是采集器,也能是一个「自动化的用户」。

相关推荐
小宋10211 小时前
AI 爬虫把大学图书馆站点拖垮:按行为指纹给爬虫分类、按类发配额、用边缘缓存分层,以带宽成本结构和真实用户 P95 延迟定档
人工智能·爬虫·分类
筑梦之人1 小时前
Elasticsearch 9.x 从入门到精通(5/7):集群、分布式与运维
运维·分布式·elasticsearch
筑梦之人2 小时前
Elasticsearch 9.x 从入门到精通(4/7):聚合分析与文本分析
大数据·elasticsearch·jenkins
数字新视界12 小时前
信创动环监控在机房环境管理中的智能化应用与实践分析
大数据·人工智能·物联网·信息与通信·动环监控系统
dozenyaoyida14 小时前
AI与大模型新闻日报 | 2026-11-08
人工智能·搜索引擎·ai·大模型·新闻
大大大大晴天16 小时前
数仓分层架构设计:ODS、DWD、DWS、ADS、DIM 如何各司其职
大数据
wuyk55519 小时前
Spider-第10讲-SQLite持久化与去重
数据库·爬虫·sqlite
东鸿电子Eastron1 天前
工厂节能降本落地指南:从精准能源计量搭建数字化管理基础
大数据·人工智能·能源·智能电表·能耗管理
吾AI科技1 天前
基于Tez引擎的 Hive SQL 性能优化 —— 为什么脚本运行越来越慢
大数据·hive·性能优化·tez