GIL 信号量 event事件 线程queue
GIL全局解释器锁
官方解释: In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe.
大译:
python解释器有很多种 最常见的就是Cpython解释器
GIL本质也是一把互斥锁:将并发变成串行牺牲效率保证数据的安全
用来阻止同一个进程下的多个线程的同时执行(同一个进程内多个线程无法实现并行但是可以实现并发)
GIL的存在是因为CPython解释器的内存管理不是线程安全的,这种不安全是来自于垃圾回收机制,每个进程下都会有一个内存管理线程在一个python的进程内,不仅有test.py的主线程或者由该主线程开发的其他线程,还有解释器开启的来及回收等解释器级别的线程,总之,所有线程都运行在这一个进程内.
所有线程的任务,都需要将代码传给解释器去执行,所以首先要解决的是能够访问到解释器代码
如果多个线程的target = work name执行流程是:
多个线程先访问到解释器的代码,即拿到执行权限,然后将target的代码交给解释器的代码执行,解释器的代码是所有线程共享的,所以来及回收线程也可能访问到解释器的代码而去执行,
这就导致了一个问题:对于共一个数据 100,在线程1执行x = 100的同时,垃圾回收机制执行的是回收100的操作,所以需要通过添加GIL锁,保证python解释器同一时间只能执行一个任务代码
问题: python的多线程没法利用多个优势,是不是就没用了
答: 研究python的多线程是否有用需要分情况讨论
例: 1.四个计算密集型任务, 每个10s 单核情况: 开线程更省资源 多核情况: 开进程 10s 开线程 40s 2.四个IO密集型任务, 每个10s 单核情况: 开线程更省资源 多核情况: 开线程更省资源
from multiprocessing import Process from threading import Thread import time, os # 计算密集型 def func(): res = 0 for i in range(10000): res *= 1 # IO 密集型 def func(): time.sleep(3) if __name__ == '__main__': print(os.cpu_count()) list = [] start = time.time() for i in range(4): p = Process(target=func) # 多进程 # 计算密集型运行时间:0.21994638442993164 # IO密集型运行时间:3.2253575325012207 p = Thread(target=func) # 多线程 # 运行时间:0.003988504409790039 # IO密集型运行时间:3.0033791065216064 list.append(p) p.start() for p in list: p.join() # 等待所有子进程/子线程运行结束后再运行主进程/主线程 end = time.time() print('运行时间:%s'%(end - start))
死锁/递归锁
指的是两个进程或线程在执行的过程中,因争抢资源而造成的一种互相等待的现象.
注意: 自己千万不要轻易处理锁
Rlock 递归锁
Rlock可以被第一个抢到锁的人连续的acquire和release
每acquire一次,锁身上的计数加一
每release一个,锁身上的计数减一
只要锁的计数不为0,其他进程/线程都不能抢
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('%s抢到了A锁'%self.name) # self.name 等价于 current_thread(),name mutexB.acquire() print('%s抢到了B锁' % self.name) mutexB.release() print('%s释放了B锁' % self.name) mutexA.release() print('%s释放了A锁' % self.name) def func2(self): mutexB.acquire() print('%s抢到了B锁' % self.name) time.sleep(1) mutexA.acquire() print('%s抢到了A锁' % self.name) mutexA.release() print('%s释放了A锁' % self.name) mutexB.release() print('%s释放了B锁' % self.name) for i in range(10): t = MyThread() t.start() # 递归锁 from threading import Thread, RLock mutexA = mutexB = RLock() class MyThread(Thread): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print('%s抢到了A锁'%self.name) # self.name 等价于 current_thread(),name mutexB.acquire() print('%s抢到了B锁' % self.name) mutexB.release() print('%s释放了B锁' % self.name) mutexA.release() print('%s释放了A锁' % self.name) def func2(self): mutexB.acquire() print('%s抢到了B锁' % self.name) time.sleep(1) mutexA.acquire() print('%s抢到了A锁' % self.name) mutexA.release() print('%s释放了A锁' % self.name) mutexB.release() print('%s释放了B锁' % self.name) for i in range(10): t = MyThread() t.start()
信号量
互斥锁: 一把锁一把钥匙
信号量: 一把锁多把钥匙
from threading import Thread, Semaphore import time import random sem = Semaphore(5) # 生成一把锁五把钥匙 def func(name): sem.acquire() print('%s进门了'%name) time.sleep(random.randint(1, 3)) sem.release() print('%s出门了'%name) for i in range(10): t = Thread(target=func, args=(i, )) t.start()
event事件
e.set() 发信号
e.wait() 等待信号
from threading import Thread, Event import time e = Event() def light(): print('红灯') time.sleep(3) e.set() print('绿灯') def car(name): print('%s等红灯'%name) e.wait() print('%s开车了'%name) t = Thread(target=light) t.start() for i in range(10): t = Thread(target=car, args=('车手%i'%i, )) t.start()
同一个进程下的多个线程本来就是数据共享,为什么还要用队列?
因为队列是 管道+锁,使用队列就不需要自己动手操作锁的问题
import queue q = queue.Queue() q.put('one') q.put('two') q.put('three') print(q.get()) # >>> one 先进先出 q = queue.LifoQueue() q.put('one') q.put('two') q.put('three') print(q.get()) # >>> three 堆栈 先进后出 q = queue.PriorityQueue() # 数字越小,优先级越高 q.put((10, 'one')) q.put((1, 'two')) q.put((5, 'three')) print(q.get()) # >>> (1, 'two')
