【编程之路】Python中的并发编程

本篇文章总结于系列视频：Python 并发编程实战，用多线程、多进程、多协程加速程序运行

1.Python对并发编程的支持

• 多线程：threading，利用 CPU 和 IO 可以同时执行的原理，让 CPU 不会干巴巴等待 IO 完成。
• 多进程：multiprocessing，利用多核 CPU 的能力，真正地并行执行任务。
• 异步 IO：asyncio，在单线程利用 CPU 和 IO 同时执行的原理，实现函数异步执行。
• 使用 Lock 对资源加锁，防止冲突访问。
• 使用 Queue 实现不同线程 / 进程之间的数据通信，实现生产者-消费者模式。
• 使用线程池 / 进程池，简化线程 / 进程的任务提交、等待结束、获取结果。
• 使用 subprocess 启动外部程序的进程，并进行输入输出交互。

2.Python并发编程有三种方式

• 多线程 Thread (multiprocessing)
• 多进程 Process (threading)
• 多协程 Coroutine (asyncio)

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

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

一个进程中可以启动 N 个线程。一个线程中可以启动 N 个协程。

2.1 多线程 Thread（threading）

• 优点：相比进程，更轻量级、占用资源少
• 缺点：
  • 相比进程：多线程只能并发执行，不能利用多 CPU（GIL）
  • 相比协程：启动数目有限制，占用内存资源，有线程切换开销

2.2 多进程 Process（multiprocessing）

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

2.3 多协程 Coroutine（asyncio）

• 优点：内存开销最少、启动协程数量最多
• 缺点：支持的库有限制（alonttp vs requests）、代码实现复杂

适用于：IO 密集型计算、需要超多任务运行、但有现成库支持的场景。

3.全局解释器锁 GIL

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

3.1 为什么有 GIL 这个东西?

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

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

4.多线程爬虫，速度快 10 倍

首先写一个简单的爬虫程序 blog_spider.py

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

def craw(url):
    r = requests.get(url)
    print(url, len(r.text))
1
2
3
4
5
6

借助 threading 实现多线程，01.multi_thread_craw.py

import time
import threading
import blog_spider

def single_thread():
    print('单线程开始')
    for url in blog_spider.urls:
        blog_spider.craw(url)
    print('单线程结束')

def multi_thread():
    print('多线程开始')
    threads = []
    for url in blog_spider.urls:
        threads.append(threading.Thread(target=blog_spider.craw, args=(url,)))
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
    print('多线程结束')

if __name__ == '__main__':
    start = time.time()
    single_thread()
    end = time.time()
    print(end-start, '秒')

    start = time.time()
    multi_thread()
    end = time.time()
    print(end - start, '秒')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31