今日内容
1，GIL全局解释器锁
2，死锁
3，信号量
4，event事件
5，队列
一：GIL全局解释器锁
什么是GIL 全局解释器锁：
它的本质也是一把互斥锁，是在CPython解释器锁，将并发变为串行的，
牺牲效率，保证数据安全性！
作用:用来阻止同一个进程下的多个线程的同时执行
(同一个进程内多个线程无法实现并行但是可以实现并发)
GIL的存在是因为CPython解释器的内存管理不是线程安全的
研究python的多线程是否有用需要分情况讨论
四个任务 计算密集型的 10s
单核情况下
开线程更省资源
多核情况下
开进程 10s
开线程 40s
四个任务 IO密集型的
单核情况下
开线程更节省资源
多核情况下
开线程更节省资
2 死锁：
from threading import Thread,Lock,current_thread,RLock
import time
# RLock 递归锁
# Rlock可以被第一个抢到锁的人连续的acquire和release
#每acquire一次锁身上的计数加1
#每release一次锁身上的计数减1
#只要锁的计数不为0 其他人都不能抢
mutexA = Lock()
mutexB = Lock()
#mutexA = mutexB = RLock() # A B现在是同一把锁
class MyThread(Thread):
def run(self): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
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()
3，信号量 （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()
4，event事件 一个子进程等待另一个子进程接受再走，或者一个子线程等待另一个子线程结束再走
即 子等子时，就用event事件，子执行完毕给另一个子发信号，另一个子只要等待到信号，就开始立即执行
案列： 红灯与车 （灯一个，车多个，即给车多个线程）
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(10):
t = Thread(target=car,args=('伞兵%s'%i,))
t.start()
5，队列（多线程优先用队列，而不是加锁）
同一个进程下的多个线程本来就是数据共享 为什么还要用队列
因为队列是管道+锁 使用队列你就不需要自己手动操作锁的问题
因为锁操作的不好极容易产生死锁现象
import queue
q = queue.Queue() # 普通队列，产生一个队列对象
q.put('hahha')
print(q.get())
q = queue.LifoQueue() #后进先出队列，==》堆栈
q.put(1)
q.put(2)
q.put(3)
print(q.get())
q = queue.PriorityQueue() #优先级队列，支持你给你放的数据设置优先级，
取的时候，数字越小 优先级越高***********
q.put((10,'haha'))
q.put((100,'hehehe'))
q.put((0,'xxxx'))
q.put((-10,'yyyy'))
print(q.get())