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 = number - 1
    print(number,current_thread().name)
    
for line in range(100):
    t = Thread(target=task)
    t.start()

验证多线程的作用

多线程的作用: 站在两个角度去看问题

四个任务,计算密集型,每个任务需要10s:
单核:
- 开启进程
  消耗资源过大
  - 四个进程: 40s
- 开启线程
  消耗资源远小于进程
  - 四个线程: 40s
多核:
- 开启进程
  
  并行执行，效率比较高
  - 四个进程: 10s
- 开启线程
  并发执行，执行效率低
  - 四个线程40s

四个任务， IO密集型，每个任务需要10s：

单核：

开启进程
消耗资源过大
- 四个进程: 40s
开启线程
消耗资源远小于进程
- 四个线程: 40s

多核:

开启进程

并行执行，效率小于多线程，因为遇到IO会立马切换CPU执行权限
- 四个进程: 40s + 开启进程消耗的额外时间
开启线程
并发执行，执行效率高于多进程
- 四个线程： 40s

from threading import Thread
from multiprocessing import Process
import os
import time

# 计算密集型
def work1():
    number = 0
    for line in range(100000000000):
        number+=1

# IO密集型
def work2():
	time.sleep(1)
    
if __name__ == '__main__':
    # 测试计算密集型
    print(os,cpu_count())
    # 开始时间
    start_time = time.time()
    list1 = []
	for line in range(6):
        p = Process(target=work1)
        # p = Thread(target=work1)
        
        list1.append(p)
        p.start()
=========================================================================
# IO密集型
print(os.cpu_count())
# 开始时间
start_time = time.time()
list1 = []
for line in range(40):
    p=Process(tanget=work2)
    # p = Thread(tanget=work2)
    
    list1.append(p)
    p.start()
   
for p in list1:
    p.join()
end_time = time.time()
print(f'程序执行时间{end_time - start_time}')

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

在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()

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 = 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')
        # 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.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


# 优先级队列
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())