GIL、Event事件、信号量、死锁、递归锁
GIL全局解释器锁
Python解释器有很多种，最常见的就是CPython解释器
GIL本质也是一把互斥锁：将并发变成串行，牺牲效率保证数据的安全
用来阻止同一个进程下的 多个线程的 同时执行
（同一个进程内的多个线程无法实现并行，但是可以实现并发）
Python的多线程没法利用多核优势，是不是就没有用了？
GIL的存在是因为CPython解释器的内存管理不是线程安全的
垃圾回收机制：
a. 引用计数
b. 标记清除
c. 分代回收
研究Python的多线程是否有用，需要分情况讨论：
（假设有四个任务，每个任务需要10s 处理完成） 1. 计算密集型： 单核情况下： 开线程更省资源（原因是开进程需要申请内存空间等操作，浪费时间） 多核情况下： 开进程处理 10s 开线程处理 40s 2. I/O密集型： 单核情况下： 开线程更省资源（原因和计算密集型的一样） 多核情况下： 开线程更省资源 （原因是 I/O秘籍情况下，线程工作方式为 切换+保存 进程申请内存空间，是要消耗很长时间的， 而线程的切换+保存基本不消耗时间） python的多线程到底有没有用 需要看情况而定 并且肯定是有用的 多进程+多线程配合使用
# I/O密集型 from multiprocessing import Process from threading import Thread import threading import os,time def work(): time.sleep(2) if __name__ == '__main__': l=[] print(os.cpu_count()) # 本机为8核 start=time.time() for i in range(400): p=Process(target=work) # 耗时9.506524085998535s多,大部分时间耗费在创建进程上 # p=Thread(target=work) # 耗时 2.0459132194519043 s多 l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))
# 计算密集型 from multiprocessing import Process from threading import Thread import os,time def work(): res=0 for i in range(100000000): res *= i if __name__ == '__main__': l=[] print(os.cpu_count()) # 本机为8核 start=time.time() for i in range(8): p=Process(target=work) # 耗时 8.460614204406738s # p=Thread(target=work) # 耗时 34.822699308395386s l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))
死锁
1. 代码表示下一步要acquire一个锁 2. 但是两个线程互相拿着对方需要的锁，于是程序就hang到这儿了 这种情况就是死锁
from threading import Thread, Lock, current_thread import time mutexA = Lock() mutexB = Lock() class MyThread(Thread): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发 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() '''执行结果： Thread-1抢到了A锁 Thread-1抢到了B锁 Thread-1释放了B锁 Thread-1释放了A锁 Thread-1抢到了B锁 Thread-2抢到了A锁 (程序到这儿并没有结束，而是一直hang着...) '''
递归锁
Rlock可以被第一个抢到锁的人连续的acquire和release
每acquire一次锁身上的计数加1
每release一次锁身上的计数减1
只要锁的计数不为0 其他人都不能抢
from threading import Thread, Lock, current_thread, RLock import time # mutexA = Lock() # mutexB = Lock() mutexA = mutexB = RLock() # A B现在是同一把锁 class MyThread(Thread): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发 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(2): t = MyThread() t.start() '''执行结果： Thread-1抢到了A锁 Thread-1抢到了B锁 Thread-1释放了B锁 Thread-1释放了A锁 Thread-1抢到了B锁 Thread-1抢到了A锁 Thread-1释放了A锁 Thread-1释放了B锁 Thread-2抢到了A锁 Thread-2抢到了B锁 Thread-2释放了B锁 Thread-2释放了A锁 Thread-2抢到了B锁 Thread-2抢到了A锁 Thread-2释放了A锁 Thread-2释放了B锁 '''
Event事件
前言
三两赛车准备出发，但是要等信号灯打出绿灯信号时，才出发
Event事件
事件处理的机制。
全局定义了一个内置标志Flag，
Flag默认值为 False，那么当程序执行 event.wait方法时就会阻塞，
如果Flag值为True，那么event.wait 方法时便不再阻塞。
涉及的方法：
set(): 将标志设为True，并通知所有处于等待阻塞状态的线程恢复运行状态。
clear(): 将标志设为False。
wait(timeout): 如果标志为True将立即返回，否则阻塞线程至等待阻塞状态，等待其他线程调用set()。
isSet(): 获取内置标志状态，返回True或False。
from threading import Event,Thread import time # 先生成一个event对象 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(3): t = Thread(target=car,args=('伞兵%s'%i,)) t.start() '''执行结果： 红灯正亮着 伞兵0正在等红灯 伞兵1正在等红灯 伞兵2正在等红灯 (此处hang3s，因为sleep了3s) 绿灯亮了 伞兵1加油门飙车了 伞兵0加油门飙车了 伞兵2加油门飙车了 '''
信号量
信号量semaphore 是一个变量，控制着对公共资源或者临界区的访问。 信号量维护着一个计数器，指定可同时访问资源或者进入临界区的线程数。 实现机制： 每次有一个线程获得信号量时，计数器-1。 若计数器为0，其他线程就停止访问信号量，直到另一个线程释放信号量。
# 信号量代码示例 from threading import Semaphore,Thread import time import random sm = Semaphore(5) # 造了一个含有五个的坑位的公共厕所 def task(name): sm.acquire() print('%s占了一个坑位'%name) time.sleep(random.random()) sm.release() print('%s释放了一个坑位' % name) for i in range(4): t = Thread(target=task,args=(i,)) t.start() '''执行结果： 0占了一个坑位 1占了一个坑位 2占了一个坑位 3占了一个坑位 1释放了一个坑位 0释放了一个坑位 2释放了一个坑位 3释放了一个坑位 '''
补充讲解三种队列
同一个进程下的多个线程本来就是数据共享 为什么还要用队列 因为队列是管道+锁 使用队列你就不需要自己手动操作锁的问题 因为锁操作的不好极容易产生死锁现象
import Queue q = queue.Queue() q.put('hahha') print(q.get()) # 执行结果：hahha q = queue.LifoQueue() q.put(1) q.put(2) q.put(3) print(q.get()) # 执行结果：3 q = queue.PriorityQueue() # 数字越小 优先级越高 q.put((10,'haha')) q.put((100,'hehehe')) q.put((0,'xxxx')) q.put((-10,'yyyy')) print(q.get()) # 执行结果：(-10, 'yyyy')
