爬虫-多线程爬虫
这篇讲什么
- 线程的两种创建方式、
start()与直接调run()的差别、join(timeout=)拦不拦得住、守护线程被杀时跑不跑finally,都有本机实测输出。 - 数据为什么会算错:
count += 1跑 160 万次一次没丢,但把一次请求夹在读和写中间,240 次只算出 40 次——锁要圈住的是整段读-改-写。 - 能快多少:10 个慢请求串行 3.12s、线程池 0.33s;纯计算时 4 个线程 1.52s 而 4 个进程 0.52s,这就是 GIL。
- 两套能直接抄的实战:线程池抓公开练习站 scrape.center 的分页详情写 CSV(附单线程 / 2 / 5 / 10 线程的实测并发对照表),以及带线程安全去重与重试的版本,外加多线程下载图片的防盗链实测。
- 线程 join/daemon、GIL 对照、锁竞态、队列生产消费、超时与重试、图片防盗链、中断与安全退出这些演示打的是本机靶站
127.0.0.1:8010:只有本机才给得了可控延迟(/slow?ms=)和可控错误码(/status/500),换成在线站就复现不出来。
线程怎么创建
官方推荐用线程池 concurrent.futures.ThreadPoolExecutor,但池子里跑的就是 threading.Thread,先把裸线程弄明白。
创建、启动、等待
1 | import threading |
1 | 启动前:t1.name = 唱歌 | t2.name(没指定)= Thread-1 (sing) | is_alive = False |
- 三个常用参数:
target、args/kwargs、name;不写name时自动编号成Thread-1 (sing),括号里带函数名。继承Thread时记得手动super().__init__(name=name),并且只覆写run,别覆写start。查岗用current_thread()、active_count()(含主线程,3 个工人时实测 4)和enumerate()(实测['MainThread', '工人0', '工人1', '工人2'])。 - 直接
t.run()就是普通调用:线程名还是MainThread、is_alive()一直是False,而且run()结尾会把_target删掉,这个对象再start()就废了,实测抛AttributeError: 'Thread' object has no attribute '_target'。join()是「主线程在这里等子线程结束」,不是「让子线程结束」;join(timeout)到点就返回,不管线程活没活完(0.31s 时那个 800ms 的请求还在跑),所以要自己看is_alive();对没start()的线程调join()会报RuntimeError: cannot join thread before it is started。
daemon:主线程走了它就死
1 | import subprocess |
1 | [daemon] 主线程只睡 0.5s,t.daemon = True |
- 子线程每 0.2s 打一次心跳、共 5 次(
heartbeat里try包着循环、finally打一行收尾),主线程只睡 0.5s 就退出;daemon=True与daemon=False各跑一遍就是上面的差别:守护版心跳停在第 3 次、finally根本没跑,非守护版主线程退完了进程还要等它跳满 5 次才执行finally,两遍总耗时实测 0.54s 与 1.05s。 daemon只能在构造时给(或start()之前设),所以守护线程里别放收尾工作:实测在守护线程里开文件写 8 行、每行sleep(0.15),主线程 0.3s 退出后文件是空的(wc -l得 0 行)——没close(),缓冲区里的内容跟着进程一起没了。
线程间要同步
不加锁真的会算错
1 | import threading |
1 | 纯 count += 1 :期望 1600000,实测 1600000,丢 0,耗时 0.12s |
- 第一行看着反直觉:8 线程各 20 万次
+= 1一次没丢。因为 CPython 的切换检查点很稀疏,这一圈里没有让出 GIL 的机会——不是没有竞态,是没撞上(把time.sleep(0)夹在读和写中间,同一份代码 18 万次就只数出 30418,丢 149582)。 - 只要读和写之间夹了会阻塞的东西(这里就是打本机靶站
/list的一次请求,真实爬虫里是一次网络往返),窗口立刻打开:240 次只数出 40 次。只锁写回完全没用:错的值早就读进来了,锁只是给「写回错误值」排队;整段都锁住值才对了,代价是 0.14s → 0.27s,请求全串行了。所以实操原则是:能不放进锁的绝对不放,最好干脆别共享——结果return出去或塞进队列,最后主线程汇总,下文实战就这么写。
锁与同步原语
1 | import threading |
1 | 同一线程第二次 acquire(timeout=0.3) = False |
Lock不可重入:同一线程第二次acquire()就是自锁,带timeout=0.3返回False,不写timeout就永久卡死、连报错都没有;它也不记数,多release()直接RuntimeError: release unlocked lock。所以一律写with lock:,异常时也会自动释放。RLock才让同一线程嵌套进入(主线程持有后第二次照样进),代价是别的线程得等它把递归全退完:工人 0.00s 就想进来,直到 0.40s 才拿到锁。Semaphore(n)是闸门:10 个任务、闸门 3,实测同时在跑的最多 3 个,0.81s 就是 4 轮 × 0.2s。普通Semaphore多release()不报错,计数从 1 变 2、闸门等于被你放开,BoundedSemaphore会拦下来;ThreadPoolExecutor(max_workers=3)已经把「池 + 闸门」打包好了。Event是个开关:set()后所有在等的线程一起走,没人 set 时wait(0.5)等满 0.51s 返回False,爬虫里拿它当「停止信号」最顺手。Condition是锁加叫醒机制,wait()先让出锁再睡、被notify()叫醒后拿到生产者放的「一页 HTML」,没人等时notify()不补发(实测返回None)。Timer本身就是线程且默认非守护,cancel()只在没到点时有效。
队列 queue
下载线程和解析线程之间别共享列表,用 queue.Queue:它内部把锁做好了,put / get 天生线程安全。
put、get 与 task_done
1 | import queue |
1 | put 满之后 qsize() = 2,full() = True,maxsize = 2 |
Queue(maxsize)满了再put就等:put(block=False)立刻抛queue.Full,put(timeout=0.5)等 0.51s 抛Full,等有别的线程get()走了一个才在 0.40s 后返回;Queue(0)是无限长,爬虫里一定要设上限,否则下载快过解析时内存一路涨。get默认一直等,get_nowait()立刻抛Empty,get(timeout=0.5)等满 0.51s 抛Empty。- 队列的
join()等的是「每个取出去的项都被task_done()确认过」(unfinished_tasks从 3 归零),不是等队列变空:一个get()配一个task_done(),task_done()多了报ValueError,少了join()永远醒不过来;3 项 × 0.2s 正好 0.60s。 qsize()/unfinished_tasks官方文档写明在多线程下只是近似值,不能当判据:实测队列里放 1 个项、3 个线程同时抢,三个线程读到的qsize()分别是 1、0、0,只有一个真拿到,另两个立刻Empty。所以别写while not q.empty(): q.get(),要用get(timeout=)配try/except Empty,或者放哨兵(塞个None表示收工)。
三种变形队列
1 | import queue |
1 | LifoQueue 取出来: [3, 2, 1] |
LifoQueue是栈,先入后出,做深度优先的链接追踪正合适;PriorityQueue按元组第一个元素排,第一个相同就继续比第二个,所以(优先级, 序号, url)最稳,别让 URL 自己去比大小,元素类型混了直接TypeError;SimpleQueue更快,但不能限长、没有task_done(配合不了join()),爬虫里一般还是用Queue。
生产者-消费者抓分页
1 | def down(page_q, html_q): # 2 个下载线程干这个 |
主线程把 page_q、html_q 都建成 Queue(maxsize=4) / Queue(maxsize=8),塞 4 个页码(其中一页重复),起 2 + 2 个线程,先 join 下载线程,再 page_q.join()、html_q.join() 等两条队列都确认完,实测:
1 | [解析0] http://127.0.0.1:8010/list?page=1 解析出 3 条 |
- 结构就三样:待抓 URL 队列、结果队列、写文件时的一把锁;下载线程只管塞、解析线程只管取,谁都不用自己判空。这里喂给队列的是本机靶站的
/list?page=,只把它当一路有固定延迟的输入源,重点在队列机制不在站点。两个队列都设了maxsize,下载跑太快会自己停下来等解析,这就是「背压」,比无脑堆内存健康;4 个页码里有一对重复,队列不做去重,所以同一页被抓了两遍、落盘 8 行,去重要自己来(实战那节就做)。
GIL 与真实收益
I/O 用线程,计算用进程
1 | import os |
1 | 串行 for 循环 10 次 :耗时 3.12s |
- 这一段的 I/O 基准打的是本机靶站的固定延迟端点
/slow?ms=300:每个请求服务端都要睡满 300ms,串行就是 10 × 0.3 ≈ 3.1s;开 10 个线程 0.33s,接近 10 倍。换成在线站就没有这种可控延迟,数字也复现不出来,所以对照留在靶站。原理是requests.get等网络时阻塞在系统调用上,会把 GIL 交出来,别的线程于是能接着发自己的请求——这就是爬虫靠线程提速的全部原理。 - GIL(全局解释器锁)让同一时刻只有一个线程在执行 Python 字节码,所以纯计算的 4 个线程不但没快,还慢了一点(1.45 → 1.52)。换成进程才是多份 GIL、多份解释器,4 个进程 0.52s,约 2.8 倍;代价是进程间只能传可序列化对象、起进程也贵:本机 2 进程 0.88s、4 进程 0.53s、8 进程 0.51s,任务只有 4 段时再多进程也榨不出油水。结论:抓页面是 I/O 密集,线程够用;只有解析特别重(大正则回溯、图片识别)才值得上进程。
max_workers 不是越大越好
同一批 30 个 ssr1 详情页(/detail/1 ~ /detail/30,每轮带一个 _=轮次 查询参数绕开 CDN 缓存,保证每次都回源),单线程和 2 线程各跑 1 轮,5、10 线程各跑 2 轮取中位数。原始输出:
1 | import statistics |
1 | workers=1 r1-1:总耗时 29.97s 成功 30/30 重试 0 次 单请求延迟 中位 0.85s 最快 0.49s 最慢 3.09s |
| 并发线程 | 中位耗时 | 加速比 | 失败/重试 |
|---|---|---|---|
| 单线程 | 29.97s | 1.00x | 0 次 |
| 2 线程 | 17.55s | 1.71x | 0 次 |
| 5 线程 | 9.37s | 3.20x | 0 次 |
| 10 线程 | 9.31s | 3.22x | 0 次 |
- 加速比是拿单线程那轮做分母。单线程到 5 线程是真金白银的提速(1.00x → 1.71x → 3.20x):抓详情页几乎全卡在等网络,多开线程就是把这些等待叠起来。
- 真正的拐点在 5 → 10:中位耗时 9.37s → 9.31s、加速比 3.20x → 3.22x,几乎原地踏步;可同一批请求的单请求延迟中位数却从 1.28s 涨到 2.30s、最慢一次冲到 5.66s。线程堆得越多,站点那边每个请求排得越久,总时长不降反微升——5 线程已经摸到这台站点的吞吐上限,再加只是把延迟摊薄、白白多开线程。全程 30/30 成功、0 次重试,scrape.center 也不封这个并发度。
- 不写
max_workers时按min(32, cpu_count + 4)算:本机 20 核 → 24(实测默认池就是 24);默认线程名是ThreadPoolExecutor-0_0这种,建议用thread_name_prefix='detail'换个好认的。对这类在线练习站,一般 4~10 就够,宁可稳一点。 - 还要留一层风险:换回本机靶站短时间连续高压跑几轮,一个请求一条新连接、
TIME_WAIT堆满就能把本机临时端口耗光,真实站点上则多半是封 IP:
1 | import socket |
1 | requests.exceptions.ConnectionError: HTTPConnectionPool(host='127.0.0.1', port=8010): Max retries exceeded with url: /list (Caused by NewConnectionError("HTTPConnection(host='127.0.0.1', port=8010): Failed to establish a new connection: [WinError 10048] 通常每个套接字地址(协议/网络地址/端口)只允许使用一次。")) |
Session 别跨线程共用
1 | import threading |
1 | 串行 40 次:每次新建连接 0.50s,复用一个 Session 0.04s |
- 复用连接省掉重建连接和 cookie 往来的开销,实测 40 次请求 0.50s → 0.04s,所以单线程也该用
Session。但上面第二组(10 个线程共用一个,打的是本机靶站的/cookies、/readcookie:各自先拿一个新 sid、睡 0.05s 再读回来)里 9 个线程读到的不是自己刚拿到的那个——官方文档说得很明确,Session不是线程安全的。 - 正解是一线程一个
Session,用threading.local()存(同样的用例实测 0 个读错),写法就是下文实战里的get_session()。
多线程爬虫实战
抓页面、抽数据的实战都走公开练习站 scrape.center——它是《Python3 网络爬虫开发实战》作者搭的、专门给爬虫练手的站点,服务端渲染,requests 直接就能拿到带数据的 HTML,而且不校验 UA/Referer,同一 IP 连发也不封。下面这份从 10 个列表页取回 100 个详情链接,再用线程池抓详情、解析成 CSV。
线程池抓分页详情
1 | import csv |
1 | 列表页 10 个,拿到 100 个详情链接(1.45s) |
submit返回Future,用字典把 future 和页码/URL 绑起来,as_completed是谁先回来先处理,不用干等最慢的那个。结果只在主线程汇总(任务只return一个 dict),全程不共享可变对象,比到处加锁省事又不会算错;落盘前rows.sort(),因为并发回来的顺序是乱的。给 Excel 看要用encoding='utf-8-sig'。- 这个站的稳定边界得实测才知道:列表页最多翻到
/page/10,/page/11实测直接 500;详情页 id 看着能到 108,但/detail/101实测就是 500,照着列表页给的链接抓才稳,别按 id 递增硬扫。至于这段该开几个线程,看前文「max_workers 不是越大越好」那张实测表——这批详情页上 5 线程就到顶了。 - 别拿这段的秒数当基准:同一段代码我隔十几分钟又跑了一次,列表页 1.45 秒变成 9.03 秒、100 条详情 28.08 秒变成 19.08 秒。列表页那层是 CDN 缓存在起作用(
ssr1的响应头带Cache-Control: max-age=600),命中时飞快、过期回源就慢;详情页大小差一个数量级,耗时主要看命中的是哪几部。所以并发实验要么像上一节那样加_=轮次强制回源,要么多跑几轮取中位数,单次数字只说明「能跑通」,不说明快慢。

线程安全的去重与重试
超时和重试的对照需要「一定超时、一定 5xx」的端点,在线练习站给不了这种可控失败,所以这一段打回本机靶站 127.0.0.1:8010 的 /status/500、/slow?ms=3000:去重和重试的机制照样成立,只是把可控的失败源摆到本机。
1 | import threading |
1 | 种子 3 个 URL,去重后真正发出去的 2 个 |
add_if_new()把查和登记放同一把锁里,是因为「先查后加」会重复干活:实测 8 个线程对同一批 URL 跑if u not in seen: seen.add(u),seen里确实是 4 条,但实际抓了 6 次(同一个 URL 被抓了 3 遍)。- 重试只对「抖得过去」的错误有用:慢接口第一次只给 2s 超时(
ReadTimeout),第二次放宽到 5s 就成功了;/status/500是硬伤,三次之后放弃并记下原因。只重试ConnectionError/Timeout/ 5xx,别重试 404、403;想要更完整的退避,可以用urllib3.util.retry.Retry挂到HTTPAdapter上。
图片多线程下载
图片防盗链是协议级演示,只能放本机靶站:本机靶站才校验 Referer,而 scrape.center 压根不校验请求头,带不带 Referer 都是 200,演示不出「不带就 403」。本机靶站的图片只认带本站 Referer 的请求,所以顺序是先验 Referer、再落盘。
1 | import os |
1 | 状态码 403 |
- 开头那四行是单独用
requests.get裸跑一张图的实测:不带 Referer 就是 403,而 403 时r.content里装的是那段拒绝页 HTML(服务器写的是<h1>403</h1><p>Referer 校验失败</p>),不是图片;不判状态码就写盘,你会得到一堆打不开的「假图片」。同样的下载写法不带 Referer 跑一遍,三个线程报的都是HTTPError: 403 Client Error: Forbidden for url: ...这种。 - 大文件别整个吞进内存:靶站给 1MB 的文件,实测
stream=False与stream=True各 0.09s 拿到 1048576 字节,3 个文件并发 0.27s;stream=True配iter_content()的好处是内存里永远只有一块。
常见的坑
池不关闭,进程退不出去
- 解释器退出前会 join 所有非守护线程,而池里的线程默认非守护(实测打出来就是
daemon = False):两个工人还卡在wait()时,主线程代码跑完也退不掉,外面timeout 5数到点把它杀了,exit=124。补一句ex.shutdown(wait=False, cancel_futures=True)也一样退不掉——已经开跑的任务取消不了,cancel_futures只能取消还没轮到执行的那些。所以with ThreadPoolExecutor(...) as ex:只是让作用界清晰,真正能退出靠的是任务本身可停。
Ctrl+C 之后线程不死
1 | import os |
1 | 主线程捕获 KeyboardInterrupt,开始收尾 |
- worker 是
while not stop.is_set(): time.sleep(0.2)的循环,主线程在except KeyboardInterrupt里决定置不置位、它是守护还是非守护,一共跑了三遍:非守护又没有停止信号时,Ctrl+C只打断主线程,worker 照跑、进程照挂(5s 后被杀掉,exit=124);把stop置上、或让 worker 变守护,都能exit=0。标准做法就两行:全局一个stop = threading.Event(),每个线程while not stop.is_set(),except KeyboardInterrupt里stop.set()再join收工。
异常、输出与输入
1 | import subprocess |
1 |
- 子线程里
1 / 0出错,只在 stderr 打上面那一段 traceback(中间省略调用它的那一帧),join()之后主线程什么都不知道,程序照样「成功地」跑完;线程池里fut.result()会把异常原样重抛,所以一定要取 result——实战里那句try: rows.append(fut.result())就是在做这件事。 - 一次
print是一个整体,四行内容都完整只是顺序随机;拆成两次sys.stdout.write就会被劈开,实测看到A 被拆成两半:B 被拆成两半:C 被拆成两半:D 被拆成两半:DDD CCC BBB AAA。日志要么一条写完,要么用一把锁把整条包起来,或者每个线程写自己的文件、最后合并。 - 子线程可以用
input(),但 stdin 是所有线程共享的一个流,谁醒着谁抢走:实测 3 个子线程把喂进去的 3 行全抢光,主线程直接EOFError。所以交互式的「按回车继续」只放主线程,子线程要暂停就等Event,别等键盘。
怎么选
| 场景 | 建议 | 依据(本机实测) |
|---|---|---|
| 就抓三五页 | 单线程 + Session |
40 次请求:新建连接 0.50s,复用 0.04s |
| 几十到几百个页面 | ThreadPoolExecutor,max_workers 取 4~10 |
ssr1 抓 30 详情页:单线程 29.97s,5 线程 9.37s(约 3.2x),再加到 10 不涨 |
| 下载和解析解耦 | Queue + 生产者消费者 |
设了 maxsize 就自带背压 |
| 深度优先追链接 | LifoQueue |
取出顺序实测 3、2、1 |
| 解析很重(大正则、识别) | ProcessPoolExecutor |
4 段计算:线程 1.52s,进程 0.52s |
| 上千并发、长连接 | 异步协程 asyncio |
线程数与内存都更吃紧 |
- 一句话记法:等网络用线程,等 CPU 用进程;想不清楚就先用
with ThreadPoolExecutor(...) as ex:加as_completed。线程解决的是「同时等」,不是「更快地算」,真要提速先分清瓶颈在网络上还是在 CPU 上。 - 配套的坑一次性列在这儿:
Session别跨线程共用、max_workers不是越大越好、任务要能停、结果回主线程汇总、去重必须一把锁。