GIL全局解释器锁
GIL全局解释器
1.GIL全局解释器锁:
1.GIL是Cpython特有的。
2.GIL本质上是一个互斥锁.
3.GIL的为了阻止同一个进程内多个线程同时执行(并行)
- 单个进程下的多个线程无法实现并行,但能实现并发
4.这把锁主要是因为CPython的内存管理不是 "线程安全" 的.
- 保证线程在执行任务时不会被垃圾回收机制回收。
2.GIL存在的目的:
GIL的存在就是为了保证线程安全的.
注意: 多个线程过来执行,一旦遇到IO操作,就会立马释放GIL解释器锁,交给下一个先进来的线程.
import time from threading import Thread, current_thread from threading import Lock number = 100 mutex = Lock() def task(): global number number2 = number time.sleep(1) number = number2 - 1 print(number, current_thread().name) for line in range(4): t = Thread(target=task) t.start() 打印结果： 99 Thread-2 99 Thread-3 99 Thread-1 99 Thread-4
验证多线程的作用
多线程的作用:
站在两个角度去看问题:
- 四个任务, 计算密集型, 每个任务需要10s:
单核:
- 开启进程
消耗资源过大
- 4个进程: 40s
- 开启线程
消耗资源远小于进程
- 4个线程: 40s
多核:
- 开启进程
并行执行,效率比较高
- 4个进程: 10s
- 开启线程
并发执行,执行效率低.
- 4个线程: 40s
- 四个任务, IO密集型, 每个任务需要10s:
单核:
- 开启进程
消耗资源过大
- 4个进程: 40s
- 开启线程
消耗资源远小于进程
- 4个线程: 40s
多核:
- 开启进程
并行执行,效率小于多线程,因为遇到IO会立马切换CPU的执行权限
- 4个进程: 40s + 开启进程消耗的额外时间
- 开启线程
并发执行,执行效率高于多进程
- 4个线程: 40s
所以：
在计算密集型的情况下:
使用多进程
在IO密集型的情况下:
使用多线程
高效执行多个进程,内多个IO密集型的程序:
使用 多进程 + 多线程
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}')
死锁现象
from threading import Lock, Thread, current_thread import time mutex_a = Lock() mutex_b = Lock() # # print(id(mutex_a)) # print(id(mutex_b)) 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()
递归锁
递归锁(了解):
用于解决死锁问题.
RLock: 比喻成万能钥匙,可以提供给多个线程去使用.
但是第一个使用的时候,会对该锁做一个引用计数.
只有引用计数为0, 才能真正释放让另一个线程去使用
from threading import RLock, Thread, Lock import time 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(0.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 Semaphore, Lock from threading import current_thread from threading import Thread import time sm = Semaphore(5) # 每个锁里面一次性运行5个 # mutex = Lock() # 每个锁里面一次运行一个 def task(): # mutex.acquire() sm.acquire() print(f'{current_thread().name}执行任务') time.sleep(1) sm.release() # mutex.release() for line in range(20): t = Thread(target=task) t.start()
线程队列
线程Q(了解级别1): 线程队列 面试会问: FIFO
- FIFO队列: 先进先出
- LIFO队列: 后进先出
- 优先级队列: 根据参数内,数字的大小进行分级,数字值越小,优先级越高
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
import queue # 优先级队列 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()) #('a优', '先', '娃娃头', 4)
