GIl全局解释器锁
Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。
对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。
在多线程环境中，Python 虚拟机按以下方式执行：
- 设置 GIL；
- 切换到一个线程去运行；
- 运行指定数量的字节码指令或者线程主动让出控制(可以调用 time.sleep(0))；
- 把线程设置为睡眠状态；
- 解锁 GIL；
- 再次重复以上所有步骤。
GIL本质上是一个互斥锁，目的是为了为了阻止同一个进程内多个线程同时执行(并行)（单个进程下的多个线程无法实现并行,但能实现并发），这把锁主要是因为CPython的内存管理不是 "线程安全" 的，GIL的存在就是为了保证线程安全的，多个线程过来执行,一旦遇到IO操作,就会立马释放GIL解释器锁,交给下一个先进来的线程
import time
from threading import Thread, current_thread
number = 100
def task():
global number
number2 = number
time.sleep(2)
number = number2 - 1
print(number, current_thread().name)
for line in range(10):
t = Thread(target=task)
t.start()多线程的作用
多线程的作用:
站在两个角度去看问题:
- 四个任务, 计算密集型, 每个任务需要10s:
单核:
- 开启进程
消耗资源过大
- 4个进程: 40s
- 开启线程
消耗资源远小于进程
- 4个线程: 40s
多核:
- 开启进程
并行执行,效率比较高
- 4个进程: 10s
- 开启线程
并发执行,执行效率低.
- 4个线程: 40s
- 四个任务, IO密集型, 每个任务需要10s:
单核:
- 开启进程
消耗资源过大
- 4个进程: 40s
- 开启线程
消耗资源远小于进程
- 4个线程: 40s
多核:
- 开启进程
并行执行,效率小于多线程,因为遇到IO会立马切换CPU的执行权限
- 4个进程: 40s + 开启进程消耗的额外时间
- 开启线程
并发执行,执行效率高于多进程
- 4个线程: 40s
'''
总结：
单核情况下：
使用线程
多核情况下：
在计算密集型的情况下:
使用多进程（可以并行执行）
在IO密集型的情况下:
使用多线程（遇到IO操作，线程切换的效率比进程切换的效率快的多）
高效执行多个进程,内多个IO密集型的程序:
使用 多进程 + 多线程
''' 死锁现象
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()
'''
>>>
用户Thread-1抢到锁a
用户Thread-1抢到锁b
用户Thread-1释放锁b
用户Thread-1释放锁a
----以上是第一个进程的正常执行
用户Thread-1抢到锁b（遇到IO，进入阻塞）用户Thread-2抢到锁a（执行第二个线程）
''''''递归锁
class MyThread(Thread):
# 线程执行任务
def run(self):
self.func1()
self.func2()
def func1(self):
print(1111)
mutex_a.acquire()
print(f'用户{self.name}抢到锁a')
# mutex_a.release()
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()
'''
111
用户Thread-1抢到锁a（线程1的锁a没有释放）
用户Thread-1抢到锁b
用户Thread-1释放锁b
用户Thread-1抢到锁b（遇到IO，执行另外的线程）
111 (输出111说明另外的线程执行了，但是递归锁不能使用)
111
111
111
111
111
111
111
111
用户Thread-1抢到锁a（线程1的func2）
用户Thread-1释放锁a
用户Thread-1释放锁b
''' 信号源
from threading import Semaphore, Lock
from threading import current_thread
from threading import Thread
import time
sm = Semaphore(5)
def task():
# mutex.acquire()
sm.acquire()
print(f'{current_thread().name}执行任务')
time.sleep(2)
sm.release()
# mutex.release()
# print(111)
#
for line in range(20):
t = Thread(target=task)
t.start()
'''
Thread-1执行任务
Thread-2执行任务
Thread-3执行任务
Thread-4执行任务
Thread-5执行任务
(sleep(2))
Thread-6执行任务
Thread-7执行任务
Thread-8执行任务
Thread-10执行任务
Thread-9执行任务
(sleep(2))
Thread-11执行任务
Thread-12执行任务Thread-13执行任务
Thread-15执行任务
Thread-14执行任务
(sleep(2))
Thread-16执行任务
Thread-17执行任务
Thread-19执行任务Thread-18执行任务
Thread-20执行任务
''' 线程队列
FIFO:先进先出队列
LIFO:后进先出队列
优先级队列:根据ASCII码决定输出顺序
import queue
#FIFO队列
q = queue.Queue()
#Lifo队列
q = queue.LifoQueue()
#优先级队列，传入元组参数，根据元组元素的ASCii码顺序决定输入顺序
q = queue.PriorityQueue()
q.put((4,'a优', '先', '娃娃头', 4))
q.put((3,'a先', '优', '娃娃头', 3))
q.put((2,'a级', '级', '娃娃头', 2))
print(q.get()) #第一个元素为2的元组