浅谈 Python 多线程、进程、协程上手体验
前言：浅谈 Python 很多人都认为 Python 的多线程是垃圾（GIL 说这锅甩不掉啊~）；本章节主要给你体验下 Python 的两个库
- Threading
- Multiprocessing
- Gevent
一.线程
Threading
Threading 模块建立在 _thread 模块之上。_thread 模块以低级、原始的方式来处理和控制线程，而 threading 模块通过对 thread 进行二次封装，提供了更方便的 api 来处理线程。
Demo:
import threading
from time import sleep
def A():
'''打印 “A” 五次'''
for x in range(5):
print("AAA")
sleep(1.0)
def B():
for x in range(5):
print("BBB")
sleep(1.0)
def main():
t1 = threading.Thread(target=A)
t2 = threading.Thread(target=B)
t1.start()
t2.start()
if __name__ == '__main__':
main()
打印结果：
AAA
BBB
BBB
AAA
BBB
AAA
BBB
AAA
BBB
AAA
[Finished in 5.3s]
如果我们按照常规的方式执行 A()、B()方法，将耗时更多，结果如下：
AAA
AAA
AAA
AAA
AAA
BBB
BBB
BBB
BBB
BBB
[Finished in 10.3s]
对比下时间就知道多线程的重要性，简单来说就是花费更少时间做事得到最高的回报。
Threading 常用方法：
t.start() : 激活线程，
t.getName() : 获取线程的名称
t.setName() ： 设置线程的名称
t.name : 获取或设置线程的名称
t.is_alive() ： 判断线程是否为激活状态
t.isAlive() ：判断线程是否为激活状态
t.setDaemon() ： 父线程打印内容后便结束了，不管子线程是否执行完毕了
t.isDaemon() ： 判断是否为守护线程
t.ident ： 获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。
t.join() ： 逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
t.run() ： 线程被cpu调度后自动执行线程对象的run方法
不一样的 _Thread
说明：Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。
Demo：
import _thread
import time
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print ("%s: %s" % ( threadName, time.ctime(time.time()) ))
try:
_thread.start_new_thread( print_time, ("Thread-1", 2, ) )
_thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print ("Error: 无法启动线程")
while True:
pass
打印结果：
Thread-1: Wed Mar 20 15:36:32 2019
Thread-1: Wed Mar 20 15:36:34 2019
Thread-2: Wed Mar 20 15:36:34 2019
Thread-1: Wed Mar 20 15:36:36 2019
Thread-2: Wed Mar 20 15:36:38 2019
Thread-1: Wed Mar 20 15:36:38 2019
[Cancelled]
_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。
- _Thread 模块已被废弃，Threading 身为它的接班人
二.进程
Multiprocessing
Multiprocessing 模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块 threading 的编程接口类似。
Demo:
from multiprocessing import Process
import time
def _proces(name):
print("Process " + name)
time.sleep(1.0)
if __name__ == "__main__":
p1 = Process(target=_proces, args=('A',))
p1.start()
p1.join()
p2 = Process(target=_proces, args=('B',))
p2.start()
p2.join()
输出打印结果如下：
Process A
Process B
[Finished in 3.2s]
Multiprocessing 常用方法：
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'hexin',)
kwargs表示调用对象的字典,kwargs={'name':'hexin','age':18}
name为子进程的名称
三.协程
Gevent
Gevent 又称微线程，在单线程上执行多个任务，用函数切换，开销极小。不通过操作系统调度，没有进程、线程的切换开销。genvent，monkey.patchall
Demo：
from gevent import monkey
monkey.patch_all()
import gevent
import urllib.request
def run(url):
print('run --> %s' % url)
try:
response = urllib.request.urlopen(url)
data = response.read()
print('%d bytes received from %s.' % (len(data), url))
except Exception as e:
print(e)
if __name__ == '__main__':
urls = ['https://www.baidu.com','https://www.jd.com','https://www.cnblogs.com/']
lis = [gevent.spawn(run, url) for url in urls]
gevent.joinall(lis)
输出打印结果如下：
run --> https://www.baidu.com
run --> https://www.jd.com
run --> https://www.cnblogs.com/
227 bytes received from https://www.baidu.com.
111917 bytes received from https://www.jd.com.
47872 bytes received from https://www.cnblogs.com/.
[Finished in 0.7s]
四.实例
多线程Demo：
from threading import Thread
from queue import Queue
from lxml import etree
import requests
class douban(Thread):
def __init__(self, url, q):
# 重写写父类的__init__方法
super(douban, self).__init__()
self.url = url
self.q = q
self.headers={}
def run(self):
self.parse_page()
def send_request(self,url):
'''
用来发送请求的方法
:return: 返回网页源码
'''
# 请求出错时，重复请求３次,
i = 0
while i <= 3:
try:
html = requests.get(url=url,headers=self.headers).content
except Exception as e:
print(u'[DEBUG] %s%s'% (e,url))
i += 1
else:
return html
def parse_page(self):
'''
解析网站源码，并采用 xpath 提取 电影名称和平分放到队列中
:return:
'''
response = self.send_request(self.url)
html = etree.HTML(response)
# 获取到一页的电影数据
node_list = html.xpath("//div[@class='info']")
for move in node_list:
# 电影名称
title = move.xpath('.//a/span/text()')[0]
# 电影主题
theme = str(move.xpath('.//div[@class="bd"]//span[@class="inq"]/text()'))
# 评分
score = move.xpath('.//div[@class="bd"]//span[@class="rating_num"]/text()')[0]
# 将每一部电影的名称跟评分加入到队列
self.q.put(title + "\t |" + score +"\t" + theme)
def main():
# 创建一个队列用来保存进程获取到的数据
q = Queue()
base_url = 'https://movie.douban.com/top250?start='
# 构造所有 url
url_list = [base_url+str(num) for num in range(0,50+1,25)]
# 保存线程
Thread_list = []
# 创建并启动线程
for url in url_list:
p = douban(url,q)
p.start()
Thread_list.append(p)
# 让主线程等待子线程执行完成
for i in Thread_list:
i.join()
while not q.empty():
print(q.get())
if __name__=="__main__":
main()
输出打印：
肖申克的救赎 |9.6 ['希望让人自由。']
霸王别姬 |9.6 ['风华绝代。']
这个杀手不太冷 |9.4 ['怪蜀黍和小萝莉不得不说的故事。']
阿甘正传 |9.4 ['一部美国近现代史。']
美丽人生 |9.5 ['最美的谎言。']
泰坦尼克号 |9.3 ['失去的才是永恒的。 ']
千与千寻 |9.3 ['最好的宫崎骏，最好的久石让。 ']
辛德勒的名单 |9.5 ['拯救一个人，就是拯救整个世界。']
..........（省略）
..........（省略）
[Finished in 0.9s]
多进程Demo：
from multiprocessing import Process, Queue
import time
from lxml import etree
import requests
class douban(Process):
def __init__(self, url, q):
# 重写写父类的__init__方法
super(douban, self).__init__()
self.url = url
self.q = q
self.headers = {}
def run(self):
self.parse_page()
def send_request(self,url):
'''
用来发送请求的方法
:return: 返回网页源码
'''
# 请求出错时，重复请求３次,
i = 0
while i <= 3:
try:
return requests.get(url=url,headers=self.headers).content
except Exception as e:
print(u'[DEBUG] %s%s'% (e,url))
i += 1
def parse_page(self):
'''
解析网站源码，并采用ｘｐａｔｈ提取 电影名称和平分放到队列中
:return:
'''
response = self.send_request(self.url)
html = etree.HTML(response)
# 获取到一页的电影数据
node_list = html.xpath("//div[@class='info']")
for move in node_list:
# 电影名称
title = move.xpath('.//a/span/text()')[0]
# 电影主题
theme = str(move.xpath('.//div[@class="bd"]//span[@class="inq"]/text()'))
# 评分
score = move.xpath('.//div[@class="bd"]//span[@class="rating_num"]/text()')[0]
# 将每一部电影的名称跟评分加入到队列
self.q.put(title + "\t |" + score +"\t" + theme)
def main():
# 创建一个队列用来保存进程获取到的数据
q = Queue()
base_url = 'https://movie.douban.com/top250?start='
# 构造所有ｕｒｌ
url_list = [base_url+str(num) for num in range(0,50+1,25)]
# 保存进程
Process_list = []
# 创建并启动进程
for url in url_list:
p = douban(url,q)
p.start()
Process_list.append(p)
# 让主进程等待子进程执行完成
for i in Process_list:
i.join()
while not q.empty():
print(q.get())
if __name__=="__main__":
main()
输出打印：
肖申克的救赎 |9.6 ['希望让人自由。']
霸王别姬 |9.6 ['风华绝代。']
这个杀手不太冷 |9.4 ['怪蜀黍和小萝莉不得不说的故事。']
阿甘正传 |9.4 ['一部美国近现代史。']
美丽人生 |9.5 ['最美的谎言。']
泰坦尼克号 |9.3 ['失去的才是永恒的。 ']
千与千寻 |9.3 ['最好的宫崎骏，最好的久石让。 ']
辛德勒的名单 |9.5 ['拯救一个人，就是拯救整个世界。']
盗梦空间 |9.3 ['诺兰给了我们一场无法盗取的梦。']
忠犬八公的故事 |9.3 ['永远都不能忘记你所爱的人。']
机器人总动员 |9.3 ['小瓦力，大人生。']
..........（省略）
..........（省略）
[Finished in 2.4s]
协程Demo：
from queue import Queue
import time
from lxml import etree
import requests
import gevent
from gevent import monkey
monkey.patch_all()
class douban(object):
def __init__(self):
# 创建一个队列用来保存进程获取到的数据
self.q = Queue()
self.headers = {}
def run(self,url):
self.parse_page(url)
def send_request(self,url):
'''
用来发送请求的方法
:return: 返回网页源码
'''
# 请求出错时，重复请求３次,
i = 0
while i <= 3:
try:
html = requests.get(url=url,headers=self.headers).content
except Exception as e:
print(u'[DEBUG] %s%s'% (e,url))
i += 1
else:
return html
def parse_page(self,url):
'''
解析网站源码，并采用ｘｐａｔｈ提取 电影名称和平分放到队列中
:return:
'''
response = self.send_request(url)
html = etree.HTML(response)
# 获取到一页的电影数据
node_list = html.xpath("//div[@class='info']")
for move in node_list:
# 电影名称
title = move.xpath('.//a/span/text()')[0]
# 电影主题
theme = str(move.xpath('.//div[@class="bd"]//span[@class="inq"]/text()'))
# 评分
score = move.xpath('.//div[@class="bd"]//span[@class="rating_num"]/text()')[0]
# 将每一部电影的名称跟评分加入到队列
self.q.put(title + "\t |" + score +"\t" + theme)
def main(self):
base_url = 'https://movie.douban.com/top250?start='
# 构造所有ｕｒｌ
url_list = [base_url+str(num) for num in range(0,225+1,25)]
# 创建协程并执行
job_list = [gevent.spawn(self.run,url) for url in url_list]
# 让线程等待所有任务完成，再继续执行。
gevent.joinall(job_list)
while not self.q.empty():
print(self.q.get())
if __name__=="__main__":
douban = douban()
douban.main()
输出打印：
肖申克的救赎 |9.6 ['希望让人自由。']
霸王别姬 |9.6 ['风华绝代。']
这个杀手不太冷 |9.4 ['怪蜀黍和小萝莉不得不说的故事。']
阿甘正传 |9.4 ['一部美国近现代史。']
美丽人生 |9.5 ['最美的谎言。']
泰坦尼克号 |9.3 ['失去的才是永恒的。 ']
千与千寻 |9.3 ['最好的宫崎骏，最好的久石让。 ']
辛德勒的名单 |9.5 ['拯救一个人，就是拯救整个世界。']
盗梦空间 |9.3 ['诺兰给了我们一场无法盗取的梦。']
忠犬八公的故事 |9.3 ['永远都不能忘记你所爱的人。']
机器人总动员 |9.3 ['小瓦力，大人生。']
三傻大闹宝莱坞 |9.2 ['英俊版憨豆，高情商版谢耳朵。']
..........（省略）
..........（省略）
[Finished in 1.0s]
总结
通过以上测试方法得出个结论：
-
多进程：密集CPU任务，需要充分使用服务器多核CPU资源，计算大量的并发请求时候，推荐 multiprocessing （多进程）
缺陷：多个进程之间通信成本高，切换开销大。 -
多线程：密集I/O任务（网络I/O，磁盘I/O，数据库I/O）爬虫比较合适多线程。推荐 threading.Thread、multiprocessing.dummy （多线程）
缺陷：同一个时间切片只能运行一个线程，不能做到高并行，但是可以做到高并发。
想要追求更有效率，多进程加异步速度会很快
下次更新各种细节与 Python 高级用法