GIL全局解释器锁
GIL全局解释器锁：基于cpython来研究解释器锁
GIL本质上是一个互斥锁
GIL的目的是为了阻止同一个进程内多个线程同时执行(并发)
单个进程下的多个线程无法实现并行，但是能实现并发
这把锁主要是因为cpython的内存管理不是“线程安全”的
内存管理：
垃圾回收机制
GIL的存在就是为了保证线程的安全
注意：
多个线程过来执行，一旦遇到io操作，就会立马释放GIL解释锁，交给下一个先进来的线程
多线程的作用：
站在两个角度看问题
'''
四个任务计算密集型，每个任务需要10s：
单核：
开启进程：
消耗资源过大
4个进程：40s
开启线程：
消耗资源远小于进程
4个线程：40s
多核:
开启进程
并行执行,效率比较高
4个进程: 10s
开启线程
并发执行,执行效率低.
4个线程: 40s
四个任务, IO密集型, 每个任务需要10s:
单核:
开启进程
消耗资源过大
4个进程: 40s
开启线程
消耗资源远小于进程
4个线程: 40s
多核:
开启进程
并行执行,效率小于多线程,因为遇到IO会立马切换CPU的执行权限
4个进程: 40s + 开启进程消耗的额外时间
开启线程
并发执行,执行效率高于多进程
4个线程: 40s
'''
from threading import Thread
from multiprocessing import Process
import os
import time
# 计算密集型
def work1():
number = 0
for line in range(100000000):
number += 1
# IO密集型
def work2():
time.sleep(1)
if __name__ == '__main__':
# 测试计算密集型
# print(os.cpu_count()) # 6
# # 开始时间
# start_time = time.time()
# list1 = []
# for line in range(6):
# p = Process(target=work1) # 程序执行时间5.300818920135498
# # p = Thread(target=work1) # 程序执行时间24.000795602798462
#
# list1.append(p)
# p.start()
# 测试IO密集型
print(os.cpu_count()) # 6
# 开始时间
start_time = time.time()
list1 = []
for line in range(40):
# p = Process(target=work2) # 程序执行时间4.445072174072266
p = Thread(target=work2) # 程序执行时间1.009237289428711
list1.append(p)
p.start()
for p in list1:
p.join()
end_time = time.time()
print(f'程序执行时间{end_time - start_time}')
# 在计算密集型的情况下:使用多进程
# 在IO密集型的情况下:使用多线程
# 高效执行多个进程,内多个IO密集型的程序:使用 多进程 + 多线程
死锁现象和递归锁
from threading import Lock, Thread, current_thread,Rlock
import time
mutex_a = Lock()
mutex_b = Lock()
#
# print(id(mutex_a))
# print(id(mutex_b))
'''
递归锁：用于解决死锁问题
RLock：比喻成一个万能钥匙，可以供给多个人去使用，但是
第一个使用的时候，会对该锁做一个引用计数，只有
引用计数为0时，才能真正释放让另一个人去使用
'''
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')
# IO操作
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()
注意
锁不能乱用
信号量
互斥锁：比喻成一个家用马桶。同时只能让一个人去使用
信号量：比喻成公厕多个马桶。同一时间可以让多个人去使用
from threading import Seaphore,Lock,Thread,current_thread
import time
sm=Semaphore(5)
muetx=Lock
def task():
sm.acquier()
print(f'{current_thread().name}执行任务')
time.sleep(1)
sm.release()
for line in range(20):
t=Thread(target=task)
t.start()
线程队列
FIFO队列：
先进先出
LIFO队列：
后进先出
优先级队列
根据参数内的，数字的大小进行分级，数字越小，优先级越高
# 普通的线程队列: 先进先出
# 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)) # a==97
q.put(('a先', '优', '娃娃头', 3)) # a==98
q.put(('a级', '级', '娃娃头', 2)) # a==99
'''
1.首先根据第一个参数判断ascii表的数值大小
2.判断第个参数中的汉字顺序.
3.再判断第二参数中数字--> 字符串数字 ---> 中文
4.以此类推
'''
print(q.get())