Python 并发 编程

Python 并发 一、简介

1. 为什么要引入并发编程？
2. 有哪些程序提速方法
3. python对并发编程的支持

1、 为什么要引入并发编程？

​ 提升程序运行的速度

​ 进阶的必备能力

2、有哪些程序提速的方法

• 单线程串行 不加改造的程序

• 多线程并发 threading

• 多CPU并行 multiprocessing

• 多机器并行 hadoop/hive/spark

3、python对并发编程的支持

• 多线程：threading，利用CPU和IO可以同时执行的原理。

• 多进程：multiprocessing，利用多核CPU的能力，真正的并行执行任务

• 异步IO：asyncio，在单线程利用CPU和IO同时执行的原理，实现函数异步执行

• 使用Lock对资源加锁，防止冲突访问

• 使用Queue实现不同线程/进程之间的数据通信，实现生产者-消费者模式

• 使用线程池Pool/进程池Pool，简化线程/进程的任务提交，等待结果，获取结果

• 使用subprocess启动外部程序的进程，并进行输入输出的交互

二、怎样选择多线程、多进程和多协程？

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

1. 什么时CPU密集型计算、IO密集型计算？
2. 多线程、多进程、多协程的对比
3. 怎样根据任务选择对应技术？

1、什么时CPU密集型计算、IO密集型计算？

• CPU密集型（CPU-bound）：CPU密集型也叫计算密集型，是指I/O在很短的时间就可以完成，CPU需要大量的计算和处理，特点时CPU占用率相当高，例如：压缩解压缩、加密解密、正则表达式搜索
• IO密集型（IO-bound）：IO密集型指的是系统运作大部分的情况是CPU在等I/O（硬盘/内存）的读/写操作，CPU占用率仍然很低。例如：文件处理程序、网络爬虫程序、读写数据库程序

2、多线程、多进程、多协程的对比

• 多进程：Process（multiprocessing）

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

• 多线程Thread(threading):

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

• 多协程Coroutine（asyncio）

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

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

• CPU密集型：使用多进程 multiprocessing

• IO密集型：满足操作任务量、有现成协程库支持、协程实现复杂度可接受，使用多协程asyncio，否则使用多线程threading

三、全局解释器锁GIL

1. python速度慢的两大原因
2. GIL是什么？
3. 为什么有GIL这个东西？
4. 怎样规避GIL带来的限制？

1、 python速度慢的两大原因

• 动态类语言，边接时边执行
• GIL，无法利用多核CPU并发执行

2、GIL是什么？

全局解释器锁（英语：Global Interpreter Lock，缩写GIL）。

是计算机程序设酒宴解释器用于同步线程的一种机制，它使得任何时刻仅有一个线程在执行。

即便在多核心处理器上，使用GIL的解释器也只允许同一时间执行一个线程。

3、为什么有GIL这个东西？

python设计初期，为了规避并发问题引入GIL，现在想去除却去除不掉了

为了解决多线程之间数据完整性和状态同步问题

python中对象的管理，是使用引用计数器进行的，引用数为0则释放对象。

开始：线程A和线程B都引用了对象obj，obj.ref_num = 2，线程A和B都想撤销对obj的引用

4、怎样规避GIL带来的限制？

• 多线程thread机制依然是有用的，用于IO密集型计算

​ 因为在I/O（read,write,send,recv,etc.）期间，线程会释放GIL，实现CPU和IO的并行因此多线程用于IO密集型计算依然可以大幅提升速度

​ 但是多线程用于CPU密集计算时，只会更加拖慢速度

• 使用multiprocessing的多进程机制实现并行计算、利用多核CPU优势

  为了应对GIL的问题，python提供了multiprocessing

四、利用多线程加速

1. python创建多线程的方法
2. 改写爬虫程序，编程多线程爬取
3. 速度对比：单线程爬虫 vs 多线程爬虫

1、python创建多线程的方法

• 准备一个函数

def my_func(a,b):
	do_craw(a,b)

• 创建一个线程

import threading
t = threading.Thread(target=my_func,args(100,200))

• 启动线程

t.start()

• 等待结束

t.join()

五、生产者消费者模式

1. 多组件的Pipeline技术架构
2. 生产者消费者爬虫的架构
3. 多线程数据通信的queue.Queue
4. 代码编写实现生产者消费者爬虫

1、多组件的Pipeline技术架构

2、生产者消费者爬虫的架构

3、多线程数据通信的queue.Queue

• queue.Queue可以用于多线程之间的、线程安全的数据通信
• 导入类库

import queue

• 创建queue

q = queue.Queue()

• 添加元素

q.put(item)

• 获取元素

item = q.get()

• 查询状态

# 查看元素的多少
q.qseze()
#判断是否为空
q.empty()
#判断是否已满
q.full()

六、线程安全问题以及Lock解决方案

1. 线程安全概念介绍
2. Lock用于解决线程安全问题
3. 示例代码演示问题以及解决方案

1、线程安全概念介绍

• 线程安全指猴哥函数、函数库在多线程环境中被调用时，能够正确地处理多个线程之间的共享变量，使程序功能正确完成。
• 由于线程的执行会随时发生切换，就造成了不可预料的结果，出现线程不安全

2、Lock用于解决线程安全问题

• 用法一：try-finally模式

import threading

lock = threding.Lock()
lock.acquire()

try:
	# do something
finally:
	lock.release()

• 用法二：with模式

import threading

lock = threading.Lock()

with lock:
	# do something

七、好用的线程池ThreadPoolExecutor

1. 线程池的原理
2. 使用线程池的好处
4. 使用线程池改造爬虫程序

1、线程池的原理

新建线程系统需要分配资源、终止线程系统需要回收资源，如果可以重用线程，则可以减去新建/终止线程的开销

2、使用线程池的好处

• 提升性能：因为减去了大量新建、终止线程的开销，重用了线程资源；
• 使用场景：适合处理突发性大量请求或大量线程完成任务、但实际任务处理时间较短
• 防御功能：能有效避免系统因为创建线程过多，而导致系统负荷过大相应便面等问题
• 代码又是：使用线程池的语法比自己新建线程执行线程更加简洁

3、ThreadPoolExcutor的使用语法

from concurrent.futures import ThreadPoolExecutor,as_completed

用法一：map函数，很简单，注意map的结果和入参是顺序对应的

with ThreadPoolExecutor() as pool:
	results = pool.map(craw, urls)
	
	for res in results:
		print(res)

用法二：future模式，更强大，注意如果用as_completed顺序是不定的

with ThreadPoolExecutor() ad pool:

	futures = [pool.submit(craw, url) for url im urls]
	
	for future in futures:
		print(future.result())
	for future in as_completed(futures):
		print(future.result())

八、在web服务中使用线程池加速

1. web服务的架构以及特点
2. 使用线程池ThreadPoolExecutor加速
3. 代码用Flask实现web服务并实现加速

1、web服务的架构以及特点

2、使用线程池ThreadPoolExecutor加速

使用线程池ThreadPoolExecutor的好处：

• 方便的将磁盘文件、数据库、远程API的IO调用并发执行
• 线程池的线程数目不会无线创建（导致系统挂掉），具有防御功能

九、使用多进程multiprocessing加速程序的运行

1. 有了多线程threading，为什么还要用多进程multiprocessing
2. 多进程multiprocessing知识梳理
3. 代码实战：单线程、多线程、多进程对比CPU密度计算速度

1、有了多线程threading，为什么还要用多进程multiprocessing

如果遇到了CPU密集型计算，多线程反而会降低执行速度！

2、多进程multiprocessing知识梳理

3、代码实战：单线程、多线程、多进程对比CPU密集计算速度

十、python异步IO实现并发爬虫

• 协程：在单线程内实现并发
  • 核心原理：用一个超级循环（其实就是while true）循环
  • 核心原理：配合IO多路复用原理（IO时CPU可以干其他事情）

• python异步IO库介绍：asyncio

import asyncio

#获取时间循环
loop = asyncio.get_event_loop()

#定义协程
async def myfunc(url):
	await get_url(url)
#创建tasks列表
tasks = [loop.create_task(myfunc(url)) for url in urls]

#执行爬虫时间列表
loop.run_until_complete(asyncio.wait(tasks))

十一、在异步IO中使用信号量控制爬虫并发度

信号量（Semaphore）

信号量（Semaphore）又称为信号量、旗语

是一个同步对象，用于保持在0至指定最大值之间的一个计数值

• 当线程完成一次对该semaphore对象的等待（wait）时，该计数值减一；
• 当线程完成一次对semaphore对象的释放（release）时，计数值加一。
• 当计数值为0，则线程等待该semaphore对象不再能成功直至该semaphore对象变成singnaled状态
• semaphore对象的计数值大于0，为signaled状态；计数值等于0，为nonsignaled状态。

使用方式1：

sem = asyncio.Semaphore(10)
async with sem:
	#work with shared resource

使用方式2：

sem = asyncio.Semaphore(10)

await sem.acquire()
try:
	# work with shared resource
finally:
	sem.release()