Spider-第16讲-线程池与竞态问题

第 16 讲 · 线程池与竞态:不改代码就把爬虫变快

本讲目标 :用线程池把「等待」重叠起来,几十行改动换来十倍提速;

同时亲手踩两个只有多线程才有 的坑------Session 不线程安全、共享状态不加锁会真的丢数。

配套代码 :spiders/s16_thread_pool.py

运行 :python spiders/s16_thread_pool.py

本讲产物 :data/s16_books_threaded.csv(48 本书,12 线程并发抓取)

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

一、先量化:48 个详情页,串行要多久

优化之前,先量出来。没有基准数字的「优化」都是心理安慰。

python 复制代码
SLOW_MS = 150
ids = list(range(1, 49))                  # 48 个详情页

t0 = time.time()
with HttpClient(base_url=site.base_url, timeout=15) as c:
    for _ in ids:
        c.get(f"/slow?ms={SLOW_MS}")      # 串行:一个一个来
serial = time.time() - t0
print(f"  串行 48 次请求         → {serial:6.2f}s")

实测输出(slogs/s16_thread_pool.log):

复制代码
  串行 48 次请求         →   8.00s

8 秒。 而这 8 秒里,你的 CPU 在干什么?基本什么也没干。

每个 /slow?ms=150 请求会「睡」150ms------模拟真实网络里一个跨机房请求的延迟。

串行执行时,线程发完请求就傻等 150ms,收到响应再发下一个。

48 × 150ms ≈ 7.2s,加上开销正好 8 秒。

关键洞察:爬虫 90% 的时间,不是在算,是在等。

等 DNS、等 TCP 握手、等服务器处理、等响应传回来。

这段时间 CPU 是闲的------这就是并发能提升的空间。


二、线程池:4 / 12 / 24 线程实测

ThreadPoolExecutor 的用法简单到离谱:把任务丢进去,它替你调度线程。

python 复制代码
for workers in (4, 12, 24):
    t0 = time.time()
    with HttpClient(base_url=site.base_url, timeout=15) as c:
        with ThreadPoolExecutor(max_workers=workers) as pool:
            list(pool.map(lambda _: c.get(f"/slow?ms={SLOW_MS}"), ids))
    dt = time.time() - t0
    print(f"  {workers:>2} 线程                  → {dt:6.2f}s   "
          f"提速 {serial / dt:4.1f} 倍")

实测输出:

复制代码
 串行 48 次请求         →   8.00s

   4 线程                  →   2.14s   提速  3.7 倍
  12 线程                  →   0.79s   提速 10.1 倍
  24 线程                  →   0.42s   提速 18.9 倍

看这个数字阶梯:

线程数 用时 提速
串行 8.00s 1.0x
4 线程 2.14s 3.7x
12 线程 0.79s 10.1x
24 线程 0.42s 18.9x

就改了几行代码,快了 10 倍以上。

一个必须诚实说明的差异

脚本里预先写好的旁白说:

「注意 24 线程那行往往不如 12 线程快,甚至更慢------线程也要抢 GIL、抢连接、抢 CPU。」

但本次实测不是这样:24 线程(0.42s)反而是最快的。

我必须如实标注这个差异。原因是:「线程开太多一定更慢」是一个过强的断言。

  • 这台机器上,任务几乎全是「等 150ms」,几乎没有 CPU 竞争,所以线程越多、重叠得越充分,就越快
  • 如果任务里有大量真实计算、或者连接池上限很低、或者机器核数很少,那 24 > 12 就可能反转

所以正确的说法不是「开多了更慢」,而是:

线程数不是越多越好,但「最优点」取决于任务类型和机器------必须实测,不能照搬别人的数字。

经验起点是 CPU 核数 × 2~5(IO 密集),先小后大试出来。

这也是为什么本讲先量基准再优化:任何性能结论,都要以你自己机器上的实测为准。


三、为什么线程池在爬虫里这么好用?------GIL 与 IO 密集型

这里必须澄清一个 Python 的「残酷事实」,否则你会对多线程产生错误的期待。

GIL(全局解释器锁) :CPython 里,同一时刻只有一个线程 能执行 Python 字节码。

这意味着:

纯 CPU 计算(比如大数运算、图像处理)用多线程,几乎无法加速。

那为什么我们的爬虫快了 10 倍?

因为爬虫是 IO 密集型 。当线程发起网络请求、等待响应时,它会主动释放 GIL ------

让别的线程去干活。于是:

复制代码
线程A:发请求 → 释放GIL,等网络...  ┐
线程B:发请求 → 释放GIL,等网络...  ├─ 三个「等待」重叠在一起
线程C:发请求 → 释放GIL,等网络...  ┘

「等待」这件事,GIL 根本管不着 ------因为等待期间线程压根没在执行 Python 代码。

所以多线程爬虫照样能提速。

任务类型 多线程有用吗 原因
IO 密集型(爬虫、读写文件、查数据库) 有用 等待时释放 GIL,等待可以重叠
CPU 密集型(大数运算、图像处理) 基本没用 大家都在抢同一把 GIL

一句话总结:GIL 挡住的是「并行计算」,挡不住「并行等待」。

而爬虫,正好就是在「等」。(想榨干多核算 CPU 密集任务,得用 multiprocessing 或 C 扩展,

但那不是爬虫的主战场。)


四、真爬数据:12 线程抓 48 页(含全局限速)

光跑空接口不够有说服力,来真的:12 个线程并发抓 48 个详情页,解析 + 落盘。

python 复制代码
limiter = RateLimiter(0.02)               # 全局:每 20ms 才放行一次
results: list[dict] = []
t0 = time.time()
with ThreadPoolExecutor(max_workers=12) as pool:
    futures = {pool.submit(task_fetch, site.base_url, bid, limiter): bid
               for bid in ids}
    for fut in as_completed(futures):     # 谁先完成先收谁的结果
        row = fut.result()
        if row:
            results.append(row)
dt = time.time() - t0
print(f"  12 线程抓 {len(ids)} 页 → 成功 {len(results)} 条,"
      f"用时 {dt:.2f}s({len(ids) / dt:.1f} 页/秒)")

实测输出:

复制代码
  12 线程抓 48 页 → 成功 48 条,用时 1.00s(48.2 页/秒)
  已落盘:s16_books_threaded.csv(13948 字节)

48 条全中,1 秒抓完,48.2 页/秒。

这里有两个关键设计,值得单独拎出来

① as_completed:谁先完成谁先收

python 复制代码
for fut in as_completed(futures):     # ← 不按提交顺序,按完成顺序

如果用 pool.map(...),它会按提交顺序 返回结果------第一个任务慢,后面都堵着。

as_completed 是「完成一个收一个 」,整体吞吐更高。真实爬虫里,

每个页面的响应时间不一样(有的快有的慢),as_completed 能让你尽早拿到结果、尽早开始处理。

② 全局限速:limiter 是共享的

python 复制代码
def task_fetch(base_url, book_id, limiter):
    limiter.wait()                        # ← 所有线程共用同一个 limiter
    ...

注释写得很直白:

limiter 是所有线程共享 的同一个对象------这样限速才是全局生效的。

如果每个线程各建一个 limiter,20 个线程就会同时放行,等于没限速。

看 RateLimiter 的实现(utils/http.py),注意那个锁:

python 复制代码
class RateLimiter:
    def __init__(self, interval: float):
        self._lock = threading.Lock()
        self._last = 0.0
    def wait(self) -> None:
        with self._lock:                  # ← 加锁,保证「读 _last / 改 _last」是原子的
            now = time.time()
            gap = self.interval - (now - self._last)
            if gap > 0:
                time.sleep(gap)
            self._last = time.time()

这是「限速」和「并发」能共存的关键 :线程可以并发地「等」,但决定「谁该等多久」的那一刻

必须串行(加锁)。否则多个线程同时读到过期的 _last,就会一起放行。


五、亲手踩坑:不加锁的计数器会丢数

前面都是「爽」的部分。这一节是线程池真正的坑。

我们写一个最朴素的计数器,让 2000 个任务各 +1,期望结果是 2000:

python 复制代码
class Counter:
    def inc(self) -> None:
        if self.locked:
            with self._lock:               # 加锁:让「读-改-写」三步不被打断
                self.value += 1
            return
        # 不加锁的写法,故意拆成三步
        tmp = self.value                   # ① 读
        for _ in range(self.widen):        # ② 假装在算别的东西(给 GIL 切换留机会)
            pass
        self.value = tmp + 1               # ③ 写回

问题就出在 ① 和 ③ 之间 :线程 A 读到 100,被切走;线程 B 也读到 100,写回 101;

A 回来拿着过期的 100 写回 101 ------ 一次自增凭空消失。

跑 3 轮,对比加锁 / 不加锁:

python 复制代码
for locked in (False, True):
    samples = []
    for _ in range(3):
        cnt = Counter(locked=locked, widen=300)
        with ThreadPoolExecutor(max_workers=16) as pool:
            list(pool.map(lambda _: cnt.inc(), range(2000)))
        samples.append(cnt.value)
    ...

实测输出:

复制代码
  2000 个任务,每个把计数器 +1,跑 3 轮,期望每轮都是 2000:
    不加锁 → [1322, 1357, 1324]   丢了 [678, 643, 676] 次
    加锁   → [2000, 2000, 2000]   丢了 [0, 0, 0] 次

看清楚这个数字:不加锁,每一轮都丢了六七百次自增。

写法 三轮结果 每一轮丢失
不加锁 [1322, 1357, 1324] 丢 678 / 643 / 676 次
加锁 [2000, 2000, 2000] 0

2000 次操作,实际只记下了 1300 多次------三分之一的计数凭空消失了。

但这里有一个更可怕的真相

看脚本里那段注释:

python 复制代码
# CPython 的 GIL 默认每 5ms 才检查一次「要不要换线程」,
# 而且只在「向后跳转」(循环)时检查。
# 我们这个 inc() 太短了,默认设置下几乎不可能被打断 ------
# 所以本地「看起来没问题」。把切换间隔调小,才能稳定复现线上那种竞态。
old_interval = sys.getswitchinterval()
sys.setswitchinterval(1e-5)               # ← 手动把切换间隔调到极小

能复现出这个 bug,是因为我们主动把 GIL 的切换间隔调到了 1e-5。

在默认设置 下,inc() 这种极短的操作几乎不可能被中途切走,这个 bug 根本复现不出来。

这正是竞态最要命的地方:本地跑 100 次都对,上线压测时随机少几条数据,你能查一星期。

为什么线上更容易出事?因为真实项目里,inc() 的「读」和「写」之间夹着的,

往往是一次数据库查询、一次日志落盘、一次网络调用 ------那些操作本来就会让线程真正让出 GIL ,

窗口比你这里刻意撑开的还大。

规则很简单

任何会被多个线程「写」的东西,都要保护起来。

具体包括:

共享对象 保护方式
计数器(value += 1) threading.Lock
去重集合(seen.add(x)) threading.Lock
结果列表(results.append(x)) threading.Lock(或改用主线程收集,见下)
写文件 必须加锁,或干脆只让主线程写

在 CPython 里,list.append 和 dict 的单个操作碰巧是「原子」的(受 GIL 保护),

所以你有时会看到有人不加锁也不崩------但那是实现细节,不是语言保证。别依赖它。

更好的做法:别共享,或只让主线程收结果

锁不是唯一的解。更省心的两种思路:

python 复制代码
# 思路一:把结果交回主线程收集(本讲 task_fetch 就是靠 as_completed 在主线程序列收)
for fut in as_completed(futures):
    row = fut.result()                    # 主线程里 append,天然安全
    if row:
        results.append(row)
python 复制代码
# 思路二:写文件交给主线程,或加锁后写
_write_lock = threading.Lock()
def save_row(row, f):
    with _write_lock:
        f.write(...)                      # 多线程写同一个文件必须加锁

多线程写同一个文件,一定要加锁。 否则两个线程的写入会交错 ,

轻则出现半行数据,重则文件损坏------而且往往在你数据爬到一半的时候才发作。


六、线程局部存储:每个线程一个 Session

还有一个更隐蔽的坑:requests.Session 不是线程安全的。

多个线程共用一个 Session,轻则 Cookie 串了,重则连接错乱。

标准解法是 threading.local():给每个线程一份独立副本。

python 复制代码
_local = threading.local()                      # 每个线程独立
_created_clients: list[HttpClient] = []         # 汇总起来,好统一关闭
_created_lock = threading.Lock()

def thread_client(base_url: str) -> HttpClient:
    """取当前线程专属的 HttpClient(没有就建一个)"""
    cli = getattr(_local, "client", None)
    if cli is None:
        cli = HttpClient(base_url=base_url, timeout=15, retries=2)
        _local.client = cli
        with _created_lock:                     # ← 往全局列表里追加,也要加锁
            _created_clients.append(cli)
    return cli

threading.local() 里的东西,对每个线程都是独立的副本 ------

所以线程 A 拿到的 session 和线程 B 拿到的,必然是不同对象。

python 复制代码
# 用的时候:
html = thread_client(base_url).get(f"/book/{book_id}").text
写法 结果
全局一个 Session 共享 ❌ Cookie 串、连接错乱、偶发异常
每线程一个 Session(threading.local) ✅ 各用各的连接池,互不干扰

注意 _created_clients.append(cli) 那句也在 with _created_lock: 里------

因为它也是「多个线程写同一个列表」。这个细节很多人会漏。

用完记得回收:

python 复制代码
def close_all_clients() -> None:
    for cli in _created_clients:
        cli.close()
    _created_clients.clear()

为什么不用 thread_local 的析构来关? 因为线程池里的线程会被复用 ,

线程结束不代表马上销毁;显式收集、显式关闭,才不会有连接泄漏。


七、线程池 vs 协程(第 12 讲)怎么选

第 12 讲我们用的是 asyncio。这一讲用线程池。两者怎么选?脚本直接打印了一张对照表:

复制代码
  维度         线程池                      asyncio
  --------------------------------------------------------------
  代码改动       几乎不用改同步代码                要重写成 async/await
  上手难度       低,会 submit/map 就能用       中,要懂事件循环
  性能上限       线程切换有开销                  更高,几千并发也能扛
  适合场景       几十~几百个请求                 几千~几万个请求
  最怕的坑       共享状态没加锁                  阻塞调用写进了协程里

一句话选型:几百个请求以内,线程池够用且省事;真到了几千几万,再上 asyncio。

别为了「先进」而先进。

线程池最大的优点是**「性价比」**:你手上已有的同步代码、依赖的第三方 SDK,

一行都不用改,直接丢进线程池就能并发。这在「已有项目要提速」的场景里,几乎是唯一现实的选择。

合规提醒

并发是一把双刃剑:它让爬虫变快,也让你能更快地把别人的服务器打崩。

  • 只在你自己的靶场,或获得明确授权的站点上练并发。
  • 并发 ≠ 可以无视频率限制。 本讲特意保留了全局限速 RateLimiter(0.02)------
    并发是为了「让等待重叠」,不是为了「把请求数堆上去」。
  • 真实站点上,请结合 robots.txt 的 Crawl-delay 和对方明确的频率要求来设限速,
    并发数越高,越要严控总频率 ;对目标做压测式并发,可能构成破坏计算机信息系统。

把 base_url 换成真实站点前的检查单:

① 并发数是否匹配「对方能承受的频率」?② 限速是不是全局 生效(不是每线程各限一次)?

③ 单任务失败会不会拖垮整批(本讲用 try/except 兜住,返回 None 继续跑)?④ 有没有设重试上限,避免雪崩?


本讲小结

能力 一句话要点
先量基准 优化前先测串行耗时------没有基准数字的优化都是自我安慰
线程池提速 ThreadPoolExecutor 几行代码换十倍提速;48 页从 8.00s → 1.00s
线程数选择 不是越多越好,最优点看任务和机器,必须实测(本机 24 线程最快)
GIL 认知 GIL 挡不住「并行等待」;爬虫是 IO 密集型,多线程照样提速
as_completed 完成一个收一个,比按提交顺序返回更高效
全局限速 RateLimiter 共享 + 内部加锁,才能让「并发」和「限速」共存
竞态踩坑 不加锁的计数器真的丢数:[1322, 1357, 1324] 而非 2000;默认设置下还复现不出来
线程安全 Session threading.local() 给每个线程一个独立 Session,避免 Cookie 串、连接错乱
写文件加锁 多线程写同一文件必须加锁,否则数据交错、文件损坏
选型 几百请求用线程池,几千几万再上 asyncio

下一讲

到这里,一套爬虫的核心能力基本齐了:

  • 发请求、解析(第 4~8 讲)
  • 存储(第 9~11 讲)
  • 登录、提交、渲染、并发(第 13~16 讲)

下一讲轻松一点,但有个实战味道很浓的任务:批量下载图片。

听起来简单,但真正做过的人都知道,麻烦全在细节里:

  • 图片 URL 里的中文、空格、非法字符,存成什么文件名?(Windows 有一串禁用字符)
  • 100 张图里有两张重名怎么办?覆盖?加序号?用哈希?
  • 传到一半网络断了,下次是从头下还是断点续传?

下一讲把这几个「文件系统层面」的实际问题,一个个解决掉。

相关推荐
学无止境小袁同学1 小时前
Google ADK 学习指南
python·llm·agent·多agent·google adk·llmagent·agent cli
郝学胜-神的一滴2 小时前
Effective Python 条款35:用类封装替代生成器异常注入
开发语言·人工智能·python·金融·pandas·scikit-learn·matplotlib
LK_072 小时前
【力扣】142. 环形链表 II |Python
python·leetcode·链表
wuyk5552 小时前
Python办公自动化-第02讲-Excel文件认知与四大库选型
开发语言·python·excel
黑十3 小时前
FDE 怎么快速搭一个可演示页面?最小前端方案
java·大数据·前端·数据库·人工智能
用户54817845909503 小时前
Java 与 Python 在大模型与智能体领域的选型
java·python
Databend3 小时前
OpenRaft 自定义 Membership,按部署拓扑选择 Quorum
大数据·数据库·数据分析
Databend4 小时前
用 SQL 排查支付故障,OpenTelemetry 接入 Databend Cloud 实战
大数据·数据库·sql
yiangL_4 小时前
1、Python 输入输出实验|print 与 input 人机交互实践
开发语言·python·人机交互