day30 GIL

GIL全局解释器锁

python解释器：

​ 1.Cpython

​ 2.Jpython

​ 3.Ppython

GIL全局解释器锁

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

​ 1.GIL本质上是一个互斥锁

​ 2.GIL为了阻止同一个进程内多个线程同时执行（并行）

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

​ 3.这把锁主要是因为Cpython的内存管理不是‘线程安全’的

​ -内存管理

​ -垃圾回收机制

​ GIL的存在就是未来了保证线程安全的

​ 注意：多个线程过来执行，一旦遇到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(10):
    t=Thread(target=task)
    t.start()
    '''99 Thread-1
98 Thread-2
97 Thread-3
96 Thread-4
95 Thread-5
94 Thread-6
93 Thread-7
92 Thread-8
91 Thread-9
90 Thread-10'''

多线程的作用

站在两个角度都去看问题

在计算密集型的情况下：使用多进程

在IO密集型的情况下：使用多线程

高效执行多个进程，进程内有多个IO密集型的程序：使用多进程+多线程

死锁

注意：锁不能乱用

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'用户{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')
        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 Lock,Thread,current_thread,RLock
import time

# mutex_a=Lock()
# mutex_b=Lock()
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')
        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-1抢到锁a
用户Thread-1释放锁a
用户Thread-1释放锁b
用户Thread-2抢到锁a
用户Thread-2抢到锁b
用户Thread-2释放锁b
用户Thread-2释放锁a
用户Thread-3抢到锁a
用户Thread-3抢到锁b
用户Thread-3释放锁b
用户Thread-3释放锁a
用户Thread-3抢到锁b
用户Thread-3抢到锁a
用户Thread-3释放锁a
用户Thread-3释放锁b
用户Thread-5抢到锁a
用户Thread-5抢到锁b
用户Thread-5释放锁b
用户Thread-5释放锁a
用户Thread-5抢到锁b
用户Thread-5抢到锁a
用户Thread-5释放锁a
用户Thread-5释放锁b
用户Thread-7抢到锁a
用户Thread-7抢到锁b
用户Thread-7释放锁b
用户Thread-7释放锁a
用户Thread-8抢到锁a
用户Thread-8抢到锁b
用户Thread-8释放锁b
用户Thread-8释放锁a
用户Thread-8抢到锁b
用户Thread-8抢到锁a
用户Thread-8释放锁a
用户Thread-8释放锁b
用户Thread-10抢到锁a
用户Thread-10抢到锁b
用户Thread-10释放锁b
用户Thread-10释放锁a
用户Thread-10抢到锁b
用户Thread-10抢到锁a
用户Thread-10释放锁a
用户Thread-10释放锁b
用户Thread-4抢到锁a
用户Thread-4抢到锁b
用户Thread-4释放锁b
用户Thread-4释放锁a
用户Thread-6抢到锁a
用户Thread-6抢到锁b
用户Thread-6释放锁b
用户Thread-6释放锁a
用户Thread-6抢到锁b
用户Thread-6抢到锁a
用户Thread-6释放锁a
用户Thread-6释放锁b
用户Thread-9抢到锁a
用户Thread-9抢到锁b
用户Thread-9释放锁b
用户Thread-9释放锁a
用户Thread-2抢到锁b
用户Thread-2抢到锁a
用户Thread-2释放锁a
用户Thread-2释放锁b
用户Thread-4抢到锁b
用户Thread-4抢到锁a
用户Thread-4释放锁a
用户Thread-4释放锁b
用户Thread-7抢到锁b
用户Thread-7抢到锁a
用户Thread-7释放锁a
用户Thread-7释放锁b
用户Thread-9抢到锁b
用户Thread-9抢到锁a
用户Thread-9释放锁a
用户Thread-9释放锁b
'''

信号量

互斥锁：比喻成一个家用马桶，同一时间只能让一个人去使用

信号量：比喻成公厕索格马桶，同一时间可以让多个人去使用

from threading import Semaphore,Lock,current_thread,Thread
import time
sm=Semaphore(5)
mutex=Lock()

def task():
    sm.acquire()
    print(f'{current_thread().name}执行任务')
    time.sleep(1)
    sm.release()

for line in range(20):
    t=Thread(target=task)
    t.start()
'''
Thread-1执行任务
Thread-2执行任务
Thread-3执行任务
Thread-4执行任务
Thread-5执行任务
Thread-6执行任务
Thread-9执行任务
Thread-8执行任务
Thread-7执行任务
Thread-10执行任务
Thread-11执行任务
Thread-13执行任务
Thread-12执行任务
Thread-15执行任务
Thread-14执行任务
Thread-16执行任务
Thread-18执行任务
Thread-20执行任务
Thread-19执行任务
Thread-17执行任务
'''

线程队列

线程Q：线程队列

-FIFO队列：先进先出

-LIFO队列：后进先出

-优先级队列：根据参数内，数字的大小进行分级，数字值越小，优先级越高

​ 1.首先根据第一个参数判断ascii表的数值大小

​ 2.判断参数中的汉字顺序

​ 3.在判断第二参数中数字—》字符串数字—》中文

​ 4.以此类推

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))
q.put(('a先', '优', '娃娃头', 3))
q.put(('a级', '级', '娃娃头', 2))
print(q.get())#('a优', '先', '娃娃头', 4)