GIL全局解释器锁
python解释器：
1.Cpython
2.Jpython
3.Ppython
GIL全局解释器锁
基于Cpython来研究全局解释器锁
1.GIL本质上是一个互斥锁
2.GIL为了阻止同一个进程内多个线程同时执行（并行）
-单个进程下的多个线程无法实现并行，但是能实现并发
3.这把锁主要是因为Cpython的内存管理不是‘线程安全’的
-内存管理
-垃圾回收机制
GIL的存在就是未来了保证线程安全的
注意：多个线程过来执行，一旦遇到IO操作，就会立马释放GIL解释器锁，交给下一个先进来的线程
import time
from threading import Thread,current_thread
number=100
def task():
global number
number2=number
# time.sleep(1)
number=number2-1
print(number,current_thread().name)
for line in range(10):
t=Thread(target=task)
t.start()
'''99 Thread-1
98 Thread-2
97 Thread-3
96 Thread-4
95 Thread-5
94 Thread-6
93 Thread-7
92 Thread-8
91 Thread-9
90 Thread-10'''
多线程的作用
站在两个角度都去看问题
在计算密集型的情况下：使用多进程
在IO密集型的情况下：使用多线程
高效执行多个进程，进程内有多个IO密集型的程序：使用多进程+多线程
死锁
注意：锁不能乱用
from threading import Lock,Thread,current_thread
import time
mutex_a=Lock()
mutex_b=Lock()
class MyThread(Thread):
#线程执行任务
def run(self):
self.func1()
self.func2()
def func1(self):
mutex_a.acquire()
# print(f'用户{current_thread().name}抢到锁a')
print(f'用户{self.name}抢到锁a')
mutex_b.acquire()
print(f'用户{self.name}抢到锁b')
mutex_b.release()
print(f'用户{self.name}释放锁b')
mutex_a.release()
print(f'用户{self.name}释放锁a')
def func2(self):
mutex_b.acquire()
print(f'用户{self.name}抢到锁b')
time.sleep(1)
mutex_a.acquire()
print(f'用户{self.name}抢到锁a')
mutex_a.release()
print(f'用户{self.name}释放锁a')
mutex_b.release()
print(f'用户{self.name}释放锁b')
for line 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'''
递归锁
用于解决死锁问题
Rlock:比喻万能钥匙，可以提供多个人去使用，但是第一个使用的时候，会对该锁做一个引用计数，只有引用计数为0，才能真正释放让另一个去使用
from threading import Lock,Thread,current_thread,RLock
import time
# mutex_a=Lock()
# mutex_b=Lock()
mutex_a=mutex_b=RLock()
class MyThread(Thread):
#线程执行任务
def run(self):
self.func1()
self.func2()
def func1(self):
mutex_a.acquire()
# print(f'用户{current_thread().name}抢到锁a')
print(f'用户{self.name}抢到锁a')
mutex_b.acquire()
print(f'用户{self.name}抢到锁b')
mutex_b.release()
print(f'用户{self.name}释放锁b')
mutex_a.release()
print(f'用户{self.name}释放锁a')
def func2(self):
mutex_b.acquire()
print(f'用户{self.name}抢到锁b')
time.sleep(1)
mutex_a.acquire()
print(f'用户{self.name}抢到锁a')
mutex_a.release()
print(f'用户{self.name}释放锁a')
mutex_b.release()
print(f'用户{self.name}释放锁b')
for line in range(10):
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-3抢到锁a
用户Thread-3抢到锁b
用户Thread-3释放锁b
用户Thread-3释放锁a
用户Thread-3抢到锁b
用户Thread-3抢到锁a
用户Thread-3释放锁a
用户Thread-3释放锁b
用户Thread-5抢到锁a
用户Thread-5抢到锁b
用户Thread-5释放锁b
用户Thread-5释放锁a
用户Thread-5抢到锁b
用户Thread-5抢到锁a
用户Thread-5释放锁a
用户Thread-5释放锁b
用户Thread-7抢到锁a
用户Thread-7抢到锁b
用户Thread-7释放锁b
用户Thread-7释放锁a
用户Thread-8抢到锁a
用户Thread-8抢到锁b
用户Thread-8释放锁b
用户Thread-8释放锁a
用户Thread-8抢到锁b
用户Thread-8抢到锁a
用户Thread-8释放锁a
用户Thread-8释放锁b
用户Thread-10抢到锁a
用户Thread-10抢到锁b
用户Thread-10释放锁b
用户Thread-10释放锁a
用户Thread-10抢到锁b
用户Thread-10抢到锁a
用户Thread-10释放锁a
用户Thread-10释放锁b
用户Thread-4抢到锁a
用户Thread-4抢到锁b
用户Thread-4释放锁b
用户Thread-4释放锁a
用户Thread-6抢到锁a
用户Thread-6抢到锁b
用户Thread-6释放锁b
用户Thread-6释放锁a
用户Thread-6抢到锁b
用户Thread-6抢到锁a
用户Thread-6释放锁a
用户Thread-6释放锁b
用户Thread-9抢到锁a
用户Thread-9抢到锁b
用户Thread-9释放锁b
用户Thread-9释放锁a
用户Thread-2抢到锁b
用户Thread-2抢到锁a
用户Thread-2释放锁a
用户Thread-2释放锁b
用户Thread-4抢到锁b
用户Thread-4抢到锁a
用户Thread-4释放锁a
用户Thread-4释放锁b
用户Thread-7抢到锁b
用户Thread-7抢到锁a
用户Thread-7释放锁a
用户Thread-7释放锁b
用户Thread-9抢到锁b
用户Thread-9抢到锁a
用户Thread-9释放锁a
用户Thread-9释放锁b
'''
信号量
互斥锁：比喻成一个家用马桶，同一时间只能让一个人去使用
信号量：比喻成公厕索格马桶，同一时间可以让多个人去使用
from threading import Semaphore,Lock,current_thread,Thread
import time
sm=Semaphore(5)
mutex=Lock()
def task():
sm.acquire()
print(f'{current_thread().name}执行任务')
time.sleep(1)
sm.release()
for line in range(20):
t=Thread(target=task)
t.start()
'''
Thread-1执行任务
Thread-2执行任务
Thread-3执行任务
Thread-4执行任务
Thread-5执行任务
Thread-6执行任务
Thread-9执行任务
Thread-8执行任务
Thread-7执行任务
Thread-10执行任务
Thread-11执行任务
Thread-13执行任务
Thread-12执行任务
Thread-15执行任务
Thread-14执行任务
Thread-16执行任务
Thread-18执行任务
Thread-20执行任务
Thread-19执行任务
Thread-17执行任务
'''
线程队列
线程Q：线程队列
-FIFO队列：先进先出
-LIFO队列：后进先出
-优先级队列：根据参数内，数字的大小进行分级，数字值越小，优先级越高
1.首先根据第一个参数判断ascii表的数值大小
2.判断参数中的汉字顺序
3.在判断第二参数中数字—》字符串数字—》中文
4.以此类推
import queue
# 普通队列：先进先出
q=queue.Queue()
q.put(1)
q.put(2)
q.put(3)
print(q.get())#1
#LIFO队列：后进先出
q=queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3)
print(q.get())#3
#优先级队列
q=queue.PriorityQueue()
q.put(('a优', '先', '娃娃头', 4))
q.put(('a先', '优', '娃娃头', 3))
q.put(('a级', '级', '娃娃头', 2))
print(q.get())#('a优', '先', '娃娃头', 4)