GIL(全局解释器锁)

在CPython中，全局解释器锁(GIL)是一个防止多个锁的互斥锁。

本机线程从执行Python字节码一次。这把锁主要是必须的因为CPython的内存管理不是线程安全。(然而，自从GIL存在时，其他功能已逐渐依赖于它所实施的保证。)

基于CPython来研究全局解释器锁

1.GIL本质是一个互斥锁

2.GIL是为了阻止同一个进程内多个线程同时执行(并行)

— 单个进程下的多个线程无法实现并行，但能实现并发

3.这把锁主要是因为CPython的内存管理不是"线程安全"的

— 内存管理

— 垃圾回收机制

注意：多个线程过来执行，一旦遇到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(100):
    t = Thread(target=task)
    t.start()

多线程的作用

站在两个角度去看问题

死锁现象

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'用户{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
# 用户Thread-2抢到锁a

递归锁

用于解决死锁问题

RLock

比喻成万能钥匙，可以提供给多个人去使用

但是第一个使用的时候，会对该锁做一个引用计数

只有引用计数为0，才能真正释放让另一个人去使用

from threading import RLock, Thread, Lock
import time

mutex_a = mutex_b = Lock()


class MyThread(Thread):
    
    # 线程执行任务
    def run(self):
        self.func1()
        self.func2()
        
    def func1(self):
        mutex_a.acquire()
        
        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 Semaphore, Lock
from threading import current_thread
from threading import Thread
import time

sm = Semaphore(5)
mutex = Lock()


def task():
    # mutex.acquore()
    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

# 优先级队列
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.以此类推
'''