第 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里必须带:pythonHEADERS = { "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、看接口是怎么回你的。
你会第一次体会到:爬虫不只是采集器,也能是一个「自动化的用户」。