8.14并发编程（三）
一、GIL全局解释器锁
Python解释器有很多种，最常见的就是CPython解释器
GIL本质也是一把互斥锁：将并发变成串行牺牲效率保证数据的安全
用来阻止同一个进程下的多个线程的同时执行(同一个进程内多个线程无法实现并行但是可以实现并发)
1.Python的多线程没法利用多核优势，是不是就是没有用了?
GIL的存在是因为CPython解释器的内存管理不是线程安全的
比如：垃圾回收机制
研究Python的多线程是否有用需要分情况讨论：
第一种：如果有四个任务，是计算密集型的，需要10s
（1）单核情况下
开线程更省资源
（2）多核情况下
开进程，需要10s
开线程，需要40s
第二种：如果有四个任务，是IO密集型的
（1）单核情况下
开线程更节省资源
（2）多核情况下
开线程更节省资
2.计算密集型
# 计算密集型 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()) # 本机为6核 start=time.time() for i in range(6): p=Process(target=work) #耗时 4.732933044433594 # p=Thread(target=work) #耗时 22.83087730407715 l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))
3.IO密集型
# IO密集型 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()) #本机为6核 start=time.time() for i in range(400): p=Process(target=work) #耗时9.001083612442017s多,大部分时间耗费在创建进程上 # p=Thread(target=work) #耗时2.051966667175293s多 l.append(p) p.start() for p in l: p.join() stop=time.time() print('run time is %s' %(stop-start))
Python的多线程到底有没有用，需要看情况而定，并且肯定是有用的
多进程 + 多线程配合使用
二、GIL与普通的互斥锁
from threading import Thread import time n = 100 def task(): global n tmp = n # time.sleep(1) # IO操作时会自动释放GIL锁 n = tmp -1 t_list = [] for i in range(100): t = Thread(target=task) t.start() t_list.append(t) for t in t_list: t.join() print(n)
三、死锁
1.Lock
from threading import Thread,Lock import time mutexA = Lock() mutexB = Lock() class MyThread(Thread): def run(self): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发 self.func1() self.func2() def func1(self): mutexA.acquire() # 2号抢了A锁 print('%s抢到了A锁'%self.name) # self.name等价于current_thread().name mutexB.acquire() # 2号此时抢不到B锁，被下面的1号抢了 print('%s抢到了B锁'%self.name) mutexB.release() print('%s释放了B锁'%self.name) mutexA.release() print('%s释放了A锁'%self.name) def func2(self): mutexB.acquire() # 1号抢了B锁 print('%s抢到了B锁'%self.name) time.sleep(1) mutexA.acquire() # 1号此时抢不到A锁，被上面的2号抢了 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()
注意：自己千万不要轻易的处理锁的问题
2.递归锁：RLock
RLock可以被第一个抢到锁的人连续的acquire和release
每acquire一次锁身上的计数加1
每release一次锁身上的计数减1
只要锁的计数不为0，其他人都不能抢
from threading import Thread,RLock import time mutexA = mutexB = RLock() # A B现在是同一把锁 class MyThread(Thread): def run(self): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发 self.func1() self.func2() def func1(self): mutexA.acquire() # A B为同一把锁，锁计数加1，为1 print('%s抢到了A锁'%self.name) # self.name等价于current_thread().name mutexB.acquire() # 锁计数加1，为2 print('%s抢到了B锁'%self.name) mutexB.release() # 锁计数减1，为1 print('%s释放了B锁'%self.name) mutexA.release() # 锁计数减1，为0，被释放 print('%s释放了A锁'%self.name) def func2(self): mutexB.acquire() # 锁计数加1，为1 print('%s抢到了B锁'%self.name) time.sleep(1) mutexA.acquire() # 锁计数加1，为2 print('%s抢到了A锁' % self.name) mutexA.release() # 锁计数减1，为1 print('%s释放了A锁' % self.name) mutexB.release() # 锁计数减1，为0，被释放 print('%s释放了B锁' % self.name) for i in range(10): t = MyThread() t.start()
3.补充：
只要类加括号实例化对象
无论传入的参数是否一样生成的对象肯定不一样
单例模式除外
class Demo(object): pass obj1 = Demo() obj2 = Demo() print(id(obj1),id(obj2)) # 内存地址不一样
四、信号量
信号量可能在不同的领域中，对应不同的知识点
互斥锁：可看为一个厕所(一个坑位)
信号量：可看为公共厕所(多个坑位)
1.怎么用：Semaphore
from threading import Semaphore,Thread import time import random sm = Semaphore(5) # 造了一个含有五个的坑位的公共厕所 def task(name): sm.acquire() print('%s占了一个坑位'%name) time.sleep(random.randint(1,3)) sm.release() for i in range(40): t = Thread(target=task,args=(i,)) t.start()
五、Event事件
导入Event，set()：发信号，wait()：等待信号
一个子进程或子线程给另一个发信号，另一个接收到信号就可以运行了
from threading import Event,Thread import time e = Event() # 先生成一个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=('老司机%s'%i,)) t.start()
六、线程queue
同一个进程下的多个线程本来就是数据共享，为什么还要用队列？
因为队列是管道 + 锁，使用队列你就不需要自己手动操作锁的问题
因为锁操作的不好极容易产生死锁现象
1.Queue：先进先出
q = queue.Queue() q.put('hahaha') q.put('hehehe') print(q.get()) # hahaha
2.LifoQueue：后进先出
q = queue.LifoQueue() q.put(1) q.put(2) q.put(3) print(q.get()) # 3
3.PriorityQueue：优先级队列
支持你给放入队列中的数据设置优先级
数字越小，取出时优先级越高
q = queue.PriorityQueue() q.put((10,'hahaha')) q.put((100,'hehehe')) q.put((-10,'xxxx')) # 数字越小，优先级越高 q.put((0,'yyyy')) print(q.get()) # (-10, 'xxxx')
