【一】GIL全局解释器锁
明确一点：从多线程数据共享，数据可以被更改线程数次，可以看出存在GIL全局解释器锁
"""纯理论 不影响编程 只不过面试的时候可能会被问到"""
# 官方文档
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)
"""
1.回顾
python解释器的类别有很多
Cpython Jpython Ppython
垃圾回收机制
应用计数、标记清除、分代回收
GIL只存在于CPython解释器中，不是python的特征
GIL是一把互斥锁用于阻止同一个进程下的多个线程同时执行
原因是因为CPython解释器中的垃圾回收机制不是线程安全的
反向验证GIL的存在 如果不存在会产生垃圾回收机制与正常线程之间数据错乱
GIL是加在CPython解释器上面的互斥锁
同一个进程下的多个线程要想执行必须先抢GIL锁 所以同一个进程下多个线程肯定不能同时运行 即无法利用多核优势
强调:同一个进程下的多个线程不能同时执行即不能利用多核优势
很多不懂python的程序员会喷python是垃圾 速度太慢 有多核都不能用
反怼:虽然用一个进程下的多个线程不能利用多核优势 但是还可以开设多进程!!!
再次强调:python的多线程就是垃圾!!!
反怼:要结合实际情况
如果多个任务都是IO密集型的 那么多线程更有优势(消耗的资源更少)
多道技术:切换+保存状态
如果多个任务都是计算密集型 那么多线程确实没有优势 但是可以用多进程
CPU越多越好
以后用python就可以多进程下面开设多线程从而达到效率最大化
"""
1.所有的解释型语言都无法做到同一个进程下多个线程利用多核优势
2.GIL在实际编程中其实不用考虑
【二】GIL与普通互斥锁区别
1.先验证GIL的存在
谁先抢到谁就先处理数据
from threading import Thread, Lock
import time
money = 100
def task():
global money
money -= 1#GIL加在这里
for i in range(100): # 创建一百个线程
t = Thread(target=task)
t.start()
print(money)#0，由于GIL的存在，一次只能一个线程获得锁
2.当睡了 0.1s 后---》所有线程都拿到了money=100之后，才去都去抢那把 GIL 锁住的数据，当所有子线程都抢到后再去修改数据就变成了 99
from threading import Thread, Lock
money = 100
def task():
global money
temp = money
time.sleep(0.1)
money -= temp
def main():
t_list = []
for i in range(100):
t = Thread(target=task)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(money)
if __name__ == '__main__':
main()
# 99
3.要改变睡眠了之后被同时取数据，产生数据错乱
自动加锁并解锁
子线程启动 ， 后先去抢 GIL 锁 ， 进入 IO 自动释放 GIL 锁 ， 但是自己加的锁还没解开 ，其他线程资源能抢到 GIL 锁，但是抢不到互斥锁
最终 GIL 回到 互斥锁的那个进程上，处理数据
from threading import Thread, Lock
import time
money = 100
mutex = Lock()
def task():
global money
mutex.acquire()
tmp = money
time.sleep(0.1)
money = tmp - 1
mutex.release()
"""
抢锁放锁也有简便写法(with上下文管理)
with mutex:
pass
"""
t_list = []
for i in range(100): # 创建一百个线程
t = Thread(target=task)
t.start()
t_list.append(t)
for t in t_list:
t.join()
# 为了确保结构正确 应该等待所有的线程运行完毕再打印money
print(money)
【三】递归锁
可以被连续的 acquire 和 release
但是只能被第一个抢到这把锁上执行上述操作
他的内部有一个计数器，每acquire一次计数 +1 每release一次 计数-1
只要计数不为0，那么其他人都无法抢到该锁
from threading import Thread, Lock, RLock
import time
拿了就放
# 两个变量同时指向一把锁
metexA = metexB = RLock()
# 类只要加括号多次 产生的肯定不同的对象
# 如果你想要实现多次加括号等到的是相同的对象 - 单例模式
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
metexA.acquire()
# self.name：获取当前线程名
print(f'{self.name} 抢到了A锁')
metexB.acquire()
print(f'{self.name} 抢到了B锁')
metexB.release()
metexA.release()
def func2(self):
metexB.acquire()
# self.name：获取当前线程名
print(f'{self.name} 抢到了A锁')
time.sleep(2)
metexA.acquire()
print(f'{self.name} 抢到了B锁')
metexA.release()
metexB.release()
def main():
for i in range(10):
t = MyThread()
t.start()
if __name__ == '__main__':
main()
# Thread-1 抢到了A锁
# Thread-1 抢到了B锁
# Thread-1 抢到了A锁
# Thread-1 抢到了B锁
# Thread-2 抢到了A锁
# Thread-2 抢到了B锁
# Thread-2 抢到了A锁
# Thread-2 抢到了B锁
# Thread-4 抢到了A锁
# Thread-4 抢到了B锁
# Thread-4 抢到了A锁
# 不会卡主正常进行
【四】死锁
-
死锁是指两个或多个进程，在执行过程中，因争夺资源而造成了互相等待的一种现象。
from threading import Thread, Lock
import time
metexA = Lock()
metexB = Lock()
# 类只要加括号多次 产生的肯定不同的对象
# 如果你想要实现多次加括号等到的是相同的对象 - 单例模式
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
metexA.acquire()
# self.name：获取当前线程名
print(f'{self.name} 抢到了A锁')
metexB.acquire()
print(f'{self.name} 抢到了B锁')
metexB.release()
metexA.release()
def func2(self):
metexB.acquire()
# self.name：获取当前线程名
print(f'{self.name} 抢到了A锁')
time.sleep(2)#阻塞了线程2就开始了，拿了A,要B，但是B已经被1拿走了，1需要A，但是已经被2拿走了，两个线程僵持
metexA.acquire()
print(f'{self.name} 抢到了B锁')
metexA.release()
metexB.release()
def main():
for i in range(10):
t = MyThread()
t.start()
if __name__ == '__main__':
main()
# Thread-1 抢到了A锁
# Thread-1 抢到了B锁
# Thread-1 抢到了A锁
# Thread-2 抢到了A锁
# 线程卡死
# 开启十个线程 第一个线程走完第一圈 回到原地抢 A 结果第二个线程已经拿到了A 导致AB卡死
