线程学习基础（1）：单线程爬虫和多线程爬虫的效率比照

山哥ol

已于 2023-01-14 01:13:02 修改

阅读量1.1k

点赞数 2

分类专栏： Python爬虫文章标签：爬虫学习 python

于 2023-01-14 01:04:36 首次发布

本文链接：https://blog.csdn.net/alijunshan/article/details/128680668

版权

Python爬虫专栏收录该内容

30 篇文章 11 订阅

订阅专栏

线程学习基础：单线程爬虫和多线程爬虫的效率比照

学了一段日子的爬虫，开始进入并发编程的学习中，两三天内，对线程的理解有了一定的进步。特别是在B站看到个别大佬的讲解，如获至宝，做笔记在这里，以方便后面复习使用。

1. 并发线程的需求

为什么引入并发线程呢？

一个网络爬虫，按顺序爬取花了1小时，采用并发下载减少到20分钟；
一个APP应用，优化前每次打开页面需要3秒，采用异步并发提升到每次200毫秒；

引入并发，就是为了提升程序运行速度。
学习并掌握并发编程，是高级别+高薪资程序员的必备能力

2. 线程提速方法

在这里插入图片描述

多线程：threading，利用CPU和IO可以同时执行的原理，让CP不再干巴巴等IO完成
多进程：multiprocessiong，利用多核CPU的能力，真正的并行执行任务
异步IO：asyncio，在单线程利用CPU和IO同时执行的原理，实现函数异步执行

具体实现的时候，就有如下模块和方法

使用Lock对资源加锁，防止冲突访问
使用Queue实现不同线程/进程之间的数据通信，实现生产者-消费者模式
使用线程池Pool/进程池Pool，简化线程/进程的任务提交、等待结束、获取结果
使用subprocess启动外部程序的进程，并进行输入输出交互

3. 如何选择并发编程的三种方式

并发编程的三种方式——多线程Thread、多进程Process和多协程Coroutine

3.1 什么是CPU密集型计算、IO密集型计算？

3.1.1 CPU密集型（CPU-bound)

CPU密集型也叫计算密集型，是指I/O在很短的时间就可以完成CPU需要大量的计算和处理，特点是CPU占用率相当高
例如:压缩解压缩、加密解密正则表达式搜索

3.1.2 IO密集型（IO-bound)

lO密集型指的是系统运作大部分的状况是CPU在等I/O(硬盘/内存)的读/写操作，CPU占用率仍然较低
例如:文件处理程序、网络爬虫程序、读写数据库程序

3.2 多线程Thread、多进程Process和多协程Coroutine对比

3.2.1 多线程Thread（threading）

优点:相比进程，更轻量级占用资源少
缺点:
- 相比讲程：多线程只能并发执行，不能利用多CPU(GIL)
- 相比协程：启动数目有限制，占用内存资源，有线程切换开销
适用于：IO密集型计算、同时运行的任务数自要求不多

3.2.2 多进程Process（multiprocessing）

优点：可以利用多核CPU并行运算
缺点：占用资源最多、可启动数目比线程少
适用于：CPU密集型计算

3.2.3 多协程 Coroutine（asyncio）

优点：内存开销最少、启动协程数量最多
缺点：支持的库有限制(aionttp vs requests、代码实现复杂
适用于：IO密集型计算、需要超多任务运行、但有现成库支持的场景

3.3 怎样根据任务选择对应技术？

如图展示。

4. Python程序运行为何慢？

头号嫌疑犯——全局解释器锁GIL

4.1 Python速度慢的两大原因

相比C/C++/Java，Python甚至比C++慢100~200倍
各大公司的推荐引擎、搜索引擎、存储引擎等底层都用C/C++
两大大原因
动态类型语言，边解释边执行
GIL无法利用多核CPU并发执行

4.2 GIL是什么？

全局解释器锁(英语: GlobalInterpreter Lock，缩写GIL)
是计算机程序设计语言解释器用于同步线程的一种机制，它使得任何时刻仅有一个线程在执行。即便在多核心处理器上，使用 GIL的解释器也只允许同一时间执行一个线程。

在这里插入图片描述

由于GIL的存在，即使电脑有多核CPU，单个时刻也只能使用1个，相比并发加速的C++、Java慢

4.3 为什么有GIL这个东西？

简而言之: Python设计初期，为了规避并发问题引入了GIL,现在想去除却去不掉了!
为了解决多线程之间数据完整性和状态同步问题，Python中对象的管理，是使用引用计数器进行的，引用数为0则释放对象。
以下图为例：
这样看来，GIL确实有好处：简化了Python对共享资源的管理。

4.4 怎样规避GIL带来的限制？

1、多线程 threading 机制依然是有用的，用于IO密集型计算。因为在 I/0 (read,write,send,recv,etc.)期间，线程会释放GIL，实现CPU和IO的并行因此多线程用于IO密集型计算依然可以大幅提升速度。但是多线程用于CPU密集型计算时，只会更加拖慢速度。
2、使用multiprocessing 的多进程机制实现并行计算、利用多核CPU优势为了应对GIL的问题，Python提供了multiprocessing。

5. 多线程使用Python

5.1 Python创建多线程的方法

在这里插入图片描述

5.2 改写爬虫程序，变成多线程爬取

写一个普通的爬虫程序

import requests

urls = [
    f"https://www.cnblogs.com/#p{page}"
    for page in range(1,51)
]

def draw(url):
    r = requests.get(url)    
    print(url, len(r.text))
    print(r.text)

draw(urls[0])

导入requests模块，定义一个要爬取的地址列表，再定义一个爬虫函数，往函数里面代入参数运行。
运行结果如图。
上面只是爬取了一个当前的网页页面，字数为70366。
再看一个多线程式的爬虫程序。

import threading
import time
import requests

urls = [
    f"https://www.cnblogs.com/#p{page}"
    for page in range(1,51)
]

def draw(url):
    r = requests.get(url)
    print(url, len(r.text))

def single_thread():
    print("single_thread begin")
    for url in urls:
        draw(url)
    print("single_thread end")


def multi_thread():
    print("multi_thread begin")
    threads = []
    for url in urls:
        threads.append(
            threading.Thread(target=draw, args=(url,), end="")
        )
    print(len(threads))
    for thread in threads:
        thread.start()
        # thread.join()    # 如果join方法加在这里，又成了单线程的了

    for thread in threads:
        thread.join()

    print("multi_thread end")


if __name__ == "__main__":
    # single_thread
    start = time.time()
    single_thread()
    end = time.time()
    print("single thread cost:", end - start, "seconds")
    singleTime = end - start

    # multi_thread
    start = time.time()
    multi_thread()
    end = time.time()
    print("multi thread cost:", end - start, "seconds")
    multiTime = end - start

    print(str(singleTime / multiTime) + 'times')