今日内容:
1、GIL全局解释器锁
2、GIL vs 自定义互斥锁
3、死锁现象与递归锁
4、信号量Semaphore
5、Event事件
6、线程queue
一、GIL全局解释器锁
1、什么是GIL全局解释器锁?
GIL本质就是一把互斥锁,相当于执行权限,每个进程内都会存在一把GIL,同一进程内的多个线程
必须抢到GIL之后才能使用Cpython解释器来执行自己的代码,即同一进程下的多个线程无法实现并行
但是可以实现并发
注:在Cpython解释器下,如果想实现并行可以开启多个进程
2、为何要有GIL?
我们首先要知道,一个多线程是怎么执行的,假设在一个进程中有三个线程,线程中是要运行的代码
①如果要运行代码,就必须要先获得CPython解释器的权限才能将代码交由解释器翻译成CPU可以理解的语言
②将翻译好的代码交由操作系统,由操作系统交给CPU执行运算
由于每个进程内都会存在一把GIL,同一进程内的多个线程,必须抢到GIL之后才能使用Cpython解释器来执行自己的代码,即同一进程下的多个线程无法实现并行,但是可以实现并发
那么我们反过来想一下,如果没有GIL的存在,那么多个线程就变成了并行的,要知道解释器中有一个垃圾回收机制,其实也是一个线程,也变成了并行,就会造成一种情况的发生,对于同一个数据100,可能线程1执行x=100的同时,而垃圾回收执行的是回收100的操作,造成了数据的丢失。
所以,为了CPython解释器的垃圾回收机制的线程安全,就必须使用GIL!
3、如何用GIL?
有了GIL,应该如何处理并发
我们有四个任务需要处理,处理方式肯定是要玩出并发的效果,解决方案可以是:
方案一:开启四个进程
方案二:一个进程下,开启四个线程
单核情况下,分析结果:
如果四个任务是计算密集型,没有多核来并行计算,方案一徒增了创建进程的开销,方案二胜
如果四个任务是I/O密集型,方案一创建进程的开销大,且进程的切换速度远不如线程,方案二胜
多核情况下,分析结果:
如果四个任务是计算密集型,多核意味着并行计算,在python中一个进程中同一时刻只有一个线程执行用不上多核,方案一胜
如果四个任务是I/O密集型,再多的核也解决不了I/O问题,方案二胜
结论:现在的计算机基本上都是多核,python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升,甚至不如串行(没有大量切换),但是,对于IO密集型的任务效率还是有显著提升的。
计算密集型:
from multiprocessing import Process from threading import Thread import os,time def task(): res=0 for i in range(100000000): res*=i if __name__ == '__main__': l=[] print(os.cpu_count()) #本机为4核 start=time.time() for i in range(4): # p=Process(target=task) #耗时16.226743459701538s p=Thread(target=task) #耗时26.44382882118225s l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))
I/O密集型:
from multiprocessing import Process from threading import Thread import os,time def task(): time.sleep(2) if __name__ == '__main__': l=[] print(os.cpu_count()) #本机为4核 start=time.time() for i in range(400): # p=Process(target=task) #耗时29.650749683380127s p=Thread(target=task) #耗时2.0773582458496094s l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))
二、GIL vs 自定义互斥锁
GIL保护的是解释器级别的数据,但是用户自己的数据需要自己加锁处理
from threading import Thread,Lock import time mutex=Lock() n=100 def task(): global n with mutex: temp=n time.sleep(0.1) n=temp-1 if __name__ == '__main__': l=[] for i in range(100): t=Thread(target=task) l.append(t) t.start() for t in l: t.join() print(n)
通过自定义互斥锁,每个线程除了要抢到GIL锁之外还要抢到自定义的锁,否则即使抢到了GIL也没有用,这样就充分保证了数据的安全性。
三、死锁现象与递归锁
死锁:两个或两个以上的进程或者线程在执行过程中,因为真多资源二造成的互相等待现象,若无外力的作用,题目都将一直处于阻塞状态,这些互相等待的进程或者线程就被称为死锁。
from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock() class MyThread(Thread): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print('