【Python之路】特别篇--多线程与多进程
并发 与 并行 的区别:
解释一：并发是在同一实体上的多个事件，并行是在不同实体上的多个事件；
解释二：并发是指两个或多个事件在同一时间间隔发生，而并行是指两个或者多个事件在同一时刻发生。
并发：就是同时做多件事情。
例如：终端用户程序利用并发功能，在输入数据的同时响应用户输入。服务器利用并发，在处理第一个请求的同时响应第二个请求。只要你希望程序同时做多件事情，就需要并发。
多线程只是并发的一种形式，但不是唯一形式。还有一种非常重要的并发类型：异步编程，它也是并发的一种形式。
并行：就是把正在执行的大量任务分割成小块，分配给多个同时运行的线程。
一般情况下，为了让CPU充分利用，并行处理都会采用多线程。所以说：并行处理是多线程的一种形式，而多线程是并发的一种形式。
Python 背景:
GIL的全称是Global Interpreter Lock(全局解释器锁)，来源是python设计之初的考虑，为了数据安全所做的决定。
Python下每个CPU在同一时间只能执行一个线程
在Python多线程下，每个线程的执行方式：
1.获取GIL
2.执行代码直到sleep或者是python虚拟机将其挂起。
3.释放GIL
可见，某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。
在python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100（ticks可以看作是python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过 sys.setcheckinterval 来调整），进行释放。
而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。
那么是不是python的多线程就完全没用了呢？
在这里我们进行分类讨论：
1、CPU密集型代码(各种循环处理、计数等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。
2、IO密集型代码(文件处理、网络爬虫等)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。
而在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。
请注意：多核多线程比单核多线程更差，原因是单核下多线程，每次释放GIL，唤醒的那个线程都能获取到GIL锁，所以能够无缝执行，但多核下，CPU0释放GIL后，其他CPU上的线程都会进行竞争，但GIL可能会马上又被CPU0拿到，导致其他几个CPU上被唤醒后的线程会醒着等待到切换时间后又进入待调度状态，这样会造成线程颠簸(thrashing)，导致效率更低
经常我们会听到老手说：“python下想要充分利用多核CPU，就用多进程”，原因是什么呢？
原因是：每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，所以在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。
所以在这里说结论：多核下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率
提供几个用于测试单线程,多线程,多进程的脚本
1.定义CPU密集的计算函数
def count(x=1, y=1):
# 使程序完成150万计算
c = 0
while c < 500000:
c += 1
x += x
y += y
2.定义IO密集的文件读写函数
def write():
f = open("test.txt", "w")
for x in range(5000000):
f.write("testwrite\n")
f.close() def read():
f = open("test.txt", "r")
lines = f.readlines()
f.close()
3.定义网络请求函数
_head = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36'}
url = "http://www.tieba.com"
def http_request():
try:
webPage = requests.get(url, headers=_head)
html = webPage.text
return {"context": html}
except Exception as e:
return {"error": e}
1.单线程运行:
#!/usr/bin/env python
# -*-coding:utf-8 -*- import time,requests # 定义CPU密集的计算函数
def count(x, y):
# 使程序完成150万计算
c = 0
while c < 500000:
c += 1
x += x
y += y # 定义IO密集的文件读写函数
def write():
f = open("test.txt", "w")
for x in range(5000000):
f.write("testwrite\n")
f.close() def read():
f = open("test.txt", "r")
lines = f.readlines()
f.close() # 定义网络请求函数:
_head = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36'}
url = "http://www.tieba.com"
def http_request():
try:
webPage = requests.get(url, headers=_head)
html = webPage.text
return {"context": html}
except Exception as e:
return {"error": e} if __name__ == '__main__': # CPU密集操作
t = time.time()
for x in range(10):
count(1, 1)
print("Line cpu", time.time() - t) # IO密集操作
t = time.time()
for x in range(10):
write()
read()
print("Line IO", time.time() - t) # 网络请求密集型操作
t = time.time()
for x in range(10):
http_request()
print("Line Http Request", time.time() - t)
2.多线程运行:
#!/usr/bin/env python
# -*-coding:utf-8 -*- import threading,time,requests # 定义CPU密集的计算函数
def count(x, y):
# 使程序完成150万计算
c = 0
while c < 500000:
c += 1
x += x
y += y # 定义IO密集的文件读写函数
def write():
f = open("test.txt", "w")
for x in range(5000000):
f.write("testwrite\n")
f.close() def read():
f = open("test.txt", "r")
lines = f.readlines()
f.close() def io():
write()
read() # 定义网络请求函数:
_head = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36'}
url = "http://www.tieba.com"
def http_request():
try:
webPage = requests.get(url, headers=_head)
html = webPage.text
return {"context": html}
except Exception as e:
return {"error": e} if __name__ == '__main__': t_list = []
t = time.time()
for x in range(10):
thread = threading.Thread(target=count,args=(1,1))
# thread = threading.Thread(target=io)
# thread = threading.Thread(target=http_request)
t_list.append(thread)
thread.start() for i in range(10):
t_list[i].join() print("Thread :", time.time() - t)
3.多进程运行:
#!/usr/bin/env python
# -*-coding:utf-8 -*- from multiprocessing import Process
import threading,time,requests # 定义CPU密集的计算函数
def count(x, y):
# 使程序完成150万计算
c = 0
while c < 500000:
c += 1
x += x
y += y # 定义IO密集的文件读写函数
def write():
f = open("test.txt", "w")
for x in range(5000000):
f.write("testwrite\n")
f.close() def read():
f = open("test.txt", "r")
lines = f.readlines()
f.close() def io():
write()
read() # 定义网络请求函数:
_head = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36'}
url = "http://www.tieba.com"
def http_request():
try:
webPage = requests.get(url, headers=_head)
html = webPage.text
return {"context": html}
except Exception as e:
return {"error": e} if __name__ == '__main__': p_list = []
t = time.time()
for x in range(10):
process = Process(target=count, args=(1,1))
# process = Process(target=io)
# process = Process(target=http_request)
p_list.append(process)
process.start() for i in range(10):
p_list[i].join() print("Multiprocess :", time.time() - t)
在多线程与多进程间 快速切换的方法:
dummy
Dummy是一个多进程包的完整拷贝。唯一不同的是，多进程包使用进程，而dummy使用线程（自然也有Python本身的一些限制）。
所以一个有的另一个也有。这样在两种模式间切换就十分简单，并且在判断框架调用时使用的是IO还是CPU模式非常有帮助.
from multiprocessing import Pool
# 切换
from multiprocessing.dummy import Pool
最新文章
- 【WCF】使用“用户名/密码”验证的合理方法
- 我觉得有意思的JavaScript题目（01-05更新中）
- linux io stack
- Win7+Eclipse+Hadoop2.6.4开发环境搭建
- android模拟器没法通过localhost访问本地服务器的解决
- css设置height 100%
- [转]Highcharts仪表盘制作
- Linux下挂载NTFS格式的U盘或硬盘
- 使用ExtJs实现文件下载
- BZOJ 2002 HNOI2010 弹飞羊 块
- Path相关评论的方法(一)
- final的用法
- Azure 基础：Blob Storage
- Java数据持久层框架 MyBatis之背景知识一
- php面向对象三大特征
- 妙用valueForKeyPath
- 3-Fiddler修改请求或响应内容
- adb命令集合
- Xcode No account for team "". Add a new account in the Accounts preference pane or verify that your accounts have valid credentials.
- GC.SuppressFinalize()的正确用法