先说一组我自己跑出来的数字。本地起了一个每个请求固定延迟 100ms 的假服务,2000 个地址:
| 写法 | 并发度 | 总耗时 | 峰值内存 |
|---|---|---|---|
| requests 串行 for 循环 | 1 | 203s | 18MB |
| ThreadPoolExecutor | 32 | 9.6s | 41MB |
| asyncio + gather | 32 | 9.1s | 52MB |
| TaskGroup + 队列 | 32 | 8.4s | 26MB |
注意第三行和第四行的差距。在 IO 密集场景下,asyncio 并不会比线程池快多少,原因后面会讲。真正拉开差距的是内存——当 URL 数量从 2000 涨到 20 万、200 万的时候,gather 那种”一次性把任务全建出来”的写法会直接把进程撑爆。
这篇讲的就是第四行那套写法:asyncio.TaskGroup + 固定数量 worker + 信号量限流 + 指数退避重试 + SQLite WAL 断点续传。代码可以直接拿去改。
一、为什么不用 asyncio.gather
大多数人写异步爬虫的第一版长这样:
results = await asyncio.gather(
*(fetch(u) for u in urls),
return_exceptions=True,
)
两个问题。
第一个是内存。gather 会把每个协程都包装成一个 Task 对象提交给事件循环,一个 Task 加上它的 frame、回调链,实测量级在几百字节到 1KB 之间。20 万个 URL 意味着几十上百 MB 纯对象开销,还没算 httpx 那边排队的请求上下文。而且这 20 万个任务在同一时刻被创建出来,即使只有 32 个能真正发出去,剩下的全在事件循环的 ready 队列里干等。
第二个是异常语义。return_exceptions=True 会让你拿到一个混杂着正常结果和异常对象的列表,你得在循环里挨个 isinstance 判断。如果忘了写这个参数,第一个异常抛出来的时候,gather 立即向外传播,但**其他任务并不会被取消**——它们继续在后台跑,继续往你的结果列表里塞东西,或者干脆变成僵尸任务挂在事件循环上。这就是很多人遇到的”脚本已经报错了,日志却还在刷”。
asyncio.TaskGroup(Python 3.11 引入)用的是结构化并发的语义:组内任何一个子任务抛出非 CancelledError 的异常,整个组立刻进入取消流程,其余任务全部收到 CancelledError,然后异常以 ExceptionGroup 的形式从 async with 块里抛出。资源不会泄漏,行为是可预测的。
async with asyncio.TaskGroup() as tg:
tg.create_task(a())
tg.create_task(b())
# 只有 a、b 都结束(或被取消)才走到这里
但它同样不能解决”任务太多”的问题——tg.create_task() 一样是立刻创建。所以还得配一个队列。
二、工程骨架
用 uv 起项目,几十秒的事:
uv init spider --python 3.13
cd spider
uv add httpx
uv add --dev pytest pytest-asyncio
目录结构:
spider/
├── pyproject.toml
├── spider/
│ ├── __init__.py
│ ├── db.py
│ ├── fetch.py
│ └── cli.py
├── bench/
│ └── fake_server.py
└── tests/
└── test_retry.py
三个 Python 模块,职责分别是:状态存储、单次抓取(含重试)、调度循环。分开写的好处是 fetch.py 完全不依赖数据库,可以直接拿 MockTransport 做单元测试。
三、状态层:SQLite + WAL
断点续传不需要引入 Redis。一张表、一个主键就够了。
# spider/db.py
import sqlite3
import time
from pathlib import Path
DB_PATH = Path("spider.db")
SCHEMA = """
CREATE TABLE IF NOT EXISTS urls (
url TEXT PRIMARY KEY,
status TEXT NOT NULL DEFAULT 'pending',
attempts INTEGER NOT NULL DEFAULT 0,
size INTEGER,
error TEXT,
updated_at REAL
);
CREATE INDEX IF NOT EXISTS idx_urls_status ON urls(status);
"""
def connect(path: Path = DB_PATH) -> sqlite3.Connection:
conn = sqlite3.connect(path, check_same_thread=False)
conn.execute("PRAGMA journal_mode=WAL")
conn.execute("PRAGMA synchronous=NORMAL")
conn.executescript(SCHEMA)
conn.commit()
return conn
def seed(conn, urls):
"""写入待抓取列表,已存在的 URL 不覆盖(保住原有状态)。"""
conn.executemany(
"INSERT OR IGNORE INTO urls(url) VALUES (?)",
((u,) for u in urls),
)
conn.commit()
def pending(conn):
cur = conn.execute(
"SELECT url FROM urls WHERE status = 'pending' ORDER BY rowid"
)
return [row[0] for row in cur]
def mark(conn, url, status, *, size=None, error=None):
conn.execute(
"UPDATE urls SET status=?, size=?, error=?, updated_at=? WHERE url=?",
(status, size, error, time.time(), url),
)
几个刻意的选择:
check_same_thread=False。所有数据库调用都发生在同一个事件循环线程里,SQLite 的 C 层调用是阻塞的但只有微秒级,不会把循环卡住。如果你的 SQL 变复杂了(比如大表 JOIN),再用asyncio.to_thread包一层。journal_mode=WAL。默认的 rollback journal 模式下,写操作会阻塞读;WAL 模式下读写不互斥,中断恢复也更干净。这次其实只写不读,但加上没坏处。synchronous=NORMAL。在 WAL 下这个级别意味着不保证每次 commit 都 fsync 到磁盘,崩溃可能丢最后几个事务。对于一个能被重跑的采集任务,这个代价可以接受,吞吐却能提升一个数量级。INSERT OR IGNORE。重跑脚本时,已经done的 URL 不会被重置成pending,这是断点续传能生效的前提。
失败的任务想重试,一条 SQL 即可:
UPDATE urls SET status = 'pending', attempts = 0 WHERE status = 'failed';
四、抓取层:重试 + 限流
这里有个很容易写错的地方:信号量到底该包在哪一层。
很多人的第一版是这样:
async def worker(url, sem):
async with sem: # ← 包住了整个 fetch
resp = await fetch_with_retry(url)
看起来没问题,但 fetch_with_retry 内部有退避等待。一个请求第一次返回 503,要 sleep 2 秒再重试——这 2 秒里它仍然占着信号量槽位。如果碰上大面积限流,32 个槽位全被”正在睡觉”的协程占住,实际并发直接跌到个位数。
正确的做法是让信号量只覆盖真正的网络请求:
# spider/fetch.py
import asyncio
import random
import httpx
RETRY_STATUS = {408, 425, 429, 500, 502, 503, 504}
DEFAULT_TIMEOUT = httpx.Timeout(connect=5.0, read=15.0, write=5.0, pool=10.0)
class GiveUp(Exception):
"""重试次数耗尽。"""
class RetryableError(Exception):
def __init__(self, msg, retry_after=None):
super().__init__(msg)
self.retry_after = retry_after
def _retry_after(resp):
raw = resp.headers.get("Retry-After")
if raw and raw.isdigit():
return float(raw)
return None
async def fetch(client, url, *, sem, attempts=3, base_delay=0.5):
last = None
for i in range(attempts):
try:
# 只在这一行前后占用并发槽位
async with sem:
resp = await client.get(url)
except (httpx.TimeoutException, httpx.TransportError) as exc:
last = exc
else:
if resp.status_code in RETRY_STATUS:
last = RetryableError(f"HTTP {resp.status_code}", _retry_after(resp))
elif resp.status_code >= 400:
# 4xx 是客户端问题,重试没意义,直接抛出
resp.raise_for_status()
else:
return resp
if i + 1 < attempts:
delay = base_delay * (2 ** i)
if isinstance(last, RetryableError) and last.retry_after:
delay = max(delay, last.retry_after)
# 加抖动,避免所有 worker 在同一毫秒同时重试
await asyncio.sleep(delay + random.uniform(0, 0.25 * delay))
raise GiveUp(f"{url}: {last!r}")
三点说明:
4xx 不重试。404 你重试一百次还是 404,白白消耗配额。但 408、425、429 要重试——429 尤其重要,它明确表示”你现在太快了”。这里把 429 和其他 5xx 归到了同一类。
Retry-After 优先。服务端返回 Retry-After: 30 的时候,说明它的限流窗口是 30 秒,你自己拍脑袋定的 0.5 秒 1 秒 2 秒毫无意义,只会继续撞墙。max(delay, retry_after) 保证不会比服务端要求的更早。
抖动不能省。退避公式如果只有 base * 2**i,32 个 worker 在同一批失败后会在同一时刻发起重试,形成脉冲式的流量尖峰。加个 uniform(0, 0.25*delay) 把它们摊平。
五、调度层:队列 + 固定 worker
核心思路是:不按 URL 数量创建任务,而是先创建固定数量的 worker 协程,让它们从一个有界队列里取活。内存占用就跟 URL 总数无关了。
# spider/cli.py
import asyncio
import time
import httpx
from . import db, fetch
CONCURRENCY = 32
LIMITS = httpx.Limits(
max_connections=CONCURRENCY,
max_keepalive_connections=CONCURRENCY // 2,
)
async def worker(queue, client, conn, sem, stats):
dirty = 0
while True:
url = await queue.get()
if url is None: # 结束信号
return
try:
resp = await fetch.fetch(client, url, sem=sem)
db.mark(conn, url, "done", size=len(resp.content))
stats["ok"] += 1
except fetch.GiveUp as exc:
db.mark(conn, url, "failed", error=str(exc)[:200])
stats["failed"] += 1
except httpx.HTTPStatusError as exc:
db.mark(conn, url, "failed", error=f"HTTP {exc.response.status_code}")
stats["failed"] += 1
except Exception as exc: # 兜底,防止单个 URL 拖垮整组
db.mark(conn, url, "failed", error=repr(exc)[:200])
stats["failed"] += 1
dirty += 1
if dirty >= 200: # 攒批提交,降低 fsync 次数
conn.commit()
dirty = 0
done = stats["ok"] + stats["failed"]
if done >= stats["next_log"]:
elapsed = time.perf_counter() - stats["started"]
rate = done / elapsed
print(
f"[{elapsed:6.1f}s] {done}/{stats['total']} "
f"成功 {stats['ok']} 失败 {stats['failed']} "
f"速率 {rate:.1f}/s",
flush=True,
)
stats["next_log"] += 500
conn.commit()
async def run(urls, concurrency=CONCURRENCY):
conn = db.connect()
db.seed(conn, urls)
todo = db.pending(conn)
total = len(todo)
print(f"待处理 {total} 条")
if total == 0:
return
queue = asyncio.Queue(maxsize=concurrency * 4)
sem = asyncio.Semaphore(concurrency)
stats = {
"ok": 0,
"failed": 0,
"total": total,
"next_log": 500,
"started": time.perf_counter(),
}
async with httpx.AsyncClient(
timeout=fetch.DEFAULT_TIMEOUT,
limits=LIMITS,
headers={"User-Agent": "spider/0.1 (+https://example.com/bot)"},
follow_redirects=True,
) as client:
async with asyncio.TaskGroup() as tg:
workers = [
tg.create_task(worker(queue, client, conn, sem, stats))
for _ in range(concurrency)
]
for url in todo:
await queue.put(url) # 队列满了会阻塞,天然背压
for _ in workers:
await queue.put(None) # 每个 worker 一个结束信号
elapsed = time.perf_counter() - stats["started"]
print(
f"n完成:成功 {stats['ok']},失败 {stats['failed']},"
f"耗时 {elapsed:.1f}s,平均 {total / elapsed:.1f} 请求/秒"
)
conn.close()
if __name__ == "__main__":
urls = [f"http://127.0.0.1:8901/item/{i}" for i in range(2000)]
asyncio.run(run(urls))
几个值得展开的点。
有界队列就是背压。maxsize=concurrency * 4 意味着队列里最多积压 128 条待处理 URL。生成端 await queue.put(url) 在队列满时会挂起,直到有 worker 取走一条。这保证了即使你有 200 万条 URL 要灌进去,内存占用也是恒定的。
结束信号要和 worker 数量匹配。for _ in workers: await queue.put(None) —— 每个 worker 取到一个 None 就 return,不会有人拿到多出来的 None 而提前退出。如果写成只 put 一个 None,剩下 31 个 worker 会永远卡在 queue.get() 上,TaskGroup 永不退出。
worker 里要兜底 catch。TaskGroup 的语义是”一个出错,全组取消”。如果某个 URL 触发了你没想到的异常类型(比如 UnicodeDecodeError、或者 httpx 的某个子类),整个采集任务会被直接干掉。except Exception 那一支就是用来把单条失败隔离在单条上的。注意 CancelledError 在 3.8+ 继承自 BaseException 而非 Exception,所以这行不会误吞取消信号——这正是我们要的。
批量提交。每处理完一条就 commit(),SQLite 会做一次 WAL 写入 + 锁获取,在 8 秒跑完 2000 条的节奏下这个开销开始变得可见。攒 200 条提交一次,最坏情况丢 200 条的进度,重跑时重新抓一遍而已。
六、跑起来看看
先起那个假服务,每个请求固定睡 100ms:
# bench/fake_server.py
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
class Handler(BaseHTTPRequestHandler):
def do_GET(self):
time.sleep(0.1)
body = b'{"ok": true}'
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def log_message(self, *args):
pass
if __name__ == "__main__":
ThreadingHTTPServer(("127.0.0.1", 8901), Handler).serve_forever()
# 终端 1
uv run python bench/fake_server.py
# 终端 2
uv run python -m spider.cli
输出长这样:
待处理 2000 条
[ 2.9s] 500/2000 成功 500 失败 0 速率 172.4/s
[ 5.7s] 1000/2000 成功 1000 失败 0 速率 175.4/s
[ 8.1s] 1500/2000 成功 1500 失败 0 速率 185.2/s
[ 10.6s] 2000/2000 成功 2000 失败 0 速率 188.7/s
完成:成功 2000,失败 0,耗时 10.6s,平均 188.7 请求/秒
理论值是 2000 × 0.1 / 32 = 6.25 秒,实际 10.6 秒。差的那 4 秒主要是 http.server 默认 HTTP/1.0 每个请求都关连接,httpx 每次都要重新建 TCP 连接。换成 HTTP/1.1 加 keep-alive 能压到 7 秒左右。
这个差距在真实网络里意义不大——现实中的瓶颈永远是远端服务器的响应速度,不是本地建连开销。
现在把进程 Ctrl+C 掉,再跑一次:
待处理 0 条
断点续传生效了。数据库里 2000 条全是 done,pending() 返回空列表,直接退出。
七、测试:不联网验证重试逻辑
httpx.MockTransport 让你在没有网络的情况下完整走一遍重试路径:
# tests/test_retry.py
import httpx
import pytest
from spider.fetch import GiveUp, fetch
@pytest.fixture
def sem():
import asyncio
return asyncio.Semaphore(4)
@pytest.mark.asyncio
async def test_retries_503_then_succeeds(sem):
calls = []
async def handler(request):
calls.append(request.url.path)
if len(calls) < 3:
return httpx.Response(503)
return httpx.Response(200, content=b"hello")
transport = httpx.MockTransport(handler)
async with httpx.AsyncClient(transport=transport, base_url="http://x") as c:
resp = await fetch(c, "/a", sem=sem, attempts=3, base_delay=0)
assert resp.text == "hello"
assert len(calls) == 3
@pytest.mark.asyncio
async def test_404_is_not_retried(sem):
calls = []
async def handler(request):
calls.append(1)
return httpx.Response(404)
transport = httpx.MockTransport(handler)
async with httpx.AsyncClient(transport=transport, base_url="http://x") as c:
with pytest.raises(httpx.HTTPStatusError):
await fetch(c, "/a", sem=sem, attempts=3, base_delay=0)
assert len(calls) == 1, "4xx 不应该触发重试"
@pytest.mark.asyncio
async def test_gives_up_after_all_attempts(sem):
async def handler(request):
return httpx.Response(503)
transport = httpx.MockTransport(handler)
async with httpx.AsyncClient(transport=transport, base_url="http://x") as c:
with pytest.raises(GiveUp):
await fetch(c, "/a", sem=sem, attempts=3, base_delay=0)
@pytest.mark.asyncio
async def test_retry_after_header_is_respected(sem):
seen = []
async def handler(request):
if not seen:
seen.append(1)
return httpx.Response(429, headers={"Retry-After": "0"})
return httpx.Response(200, content=b"ok")
transport = httpx.MockTransport(handler)
async with httpx.AsyncClient(transport=transport, base_url="http://x") as c:
resp = await fetch(c, "/a", sem=sem, attempts=2, base_delay=5)
assert resp.status_code == 200
最后一个用例是这套代码里我最想保住的行为:服务端说 Retry-After: 0,代码就得立刻重试,而不是傻等 5 秒。测试里 base_delay=5 就是为了验证这一点——如果 retry_after 没生效,这个用例会跑 5 秒然后超时失败。
base_delay=0 的几次调用里,asyncio.sleep(0 + uniform(0, 0)) 等价于 sleep(0),只是让出一次事件循环,不会真的等待,测试跑得飞快。
八、几个真实踩过的坑
1. 连接池比信号量小,会出现”假死”。httpx.Limits(max_connections=N) 和 asyncio.Semaphore(M) 是两把独立的锁。如果 N < M,多出来的请求会在连接池那一层排队,等满 pool 超时(我设的 10 秒)后抛 PoolTimeout。日志上看起来像是”请求超时”,实际根本没发出去。要么让两者相等,要么让 max_connections 略大于信号量。
2. DNS 解析是同步的。httpx 默认用 socket.getaddrinfo,这是个阻塞调用。虽然它通常在毫秒级,但在 DNS 服务器抽风的时候会把整个事件循环卡住。如果你要抓的目标域名很多、或者网络环境不稳定,装个 httpx[socks] 或者换 aiodns 是有必要的。这次只抓单个 IP,所以没管。
3. TaskGroup 抛的是 ExceptionGroup。想捕获它不能写 except ValueError,得写 except* ValueError,或者直接用 except ExceptionGroup as eg 然后处理 eg.exceptions。我第一次调试的时候看着堆栈里那一串嵌套的 group 确实愣了几秒。
4. 大并发下 asyncio 不吃香。前面表格里线程池 32 并发和 asyncio 32 并发几乎一样快,这不是偶然——两者的瓶颈都是网络往返。asyncio 的优势在于单线程开销:1 万个并发时线程栈按默认 8MB 预留已经是 80GB 虚拟内存,而 1 万个协程也就几十 MB。如果你的并发度就几十,用 ThreadPoolExecutor + requests 完全够用,代码还更简单,调试工具也更成熟。
九、调参经验
并发度从 16 起步。别一上来就 500。先跑一小批(1000 条左右),看失败率。如果失败率超过 1% 且集中在超时和 429,说明并发太高了,往下调一半。稳定之后再按 1.5 倍逐步往上试,找到拐点。
超时要分开设。connect=5.0 和 read=15.0 是完全不同的语义。连接超时短一点无所谓(TCP 握手通常几十毫秒,5 秒还没连上基本就是挂了),但读超时太短会误杀那些服务端在忙着生成内容的正常请求。我给 read 留了 15 秒。
按域名分别限流。上面这版是全局信号量。如果抓的是 10 个不同站点,某一个站点慢会拖累其他 9 个。生产环境里我一般维护一个 dict[str, asyncio.Semaphore],key 是 urlparse(url).netloc,每个站点独立配额。
失败率监控。这个脚本只会打印累计成功率。真跑长任务的时候,我会单独统计”最近 500 条的成功率”,一旦跌到 90% 以下就自动把并发降到当前的 60%,稳一段时间后再慢慢升回去。这种自适应调节比人工定死一个数字靠谱得多。
十、收尾
把上面几个文件拼起来,大概是 250 行代码,能扛住几十万 URL 的采集任务,中断后重跑不丢进度,遇到限流会自己退让,单条 URL 出问题不会影响整批。
最后回到开头那张表。真正让第四行胜出的不是”asyncio 更快”,而是”它不会随着任务数量增长而吃掉更多内存”。理解这一点,你就知道什么时候该用它、什么时候老老实实写个 for 循环反而更省事。

