10.23 总结

1.GIL全局解释器锁

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

1.GIL本质上是一个互斥锁，相当于执行权限，每个进程内都会存在一把GIL。

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

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

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

-内存管理：垃圾回收机制。

GIL的存在就是为了保证线程安全的。

注意：多个线程过来执行，一旦遇到IO操作，就会立马释放GIL解释器锁，交给下一个先进来的线程。同一进程的多个线程必须抢到GIL才能使用CPython解释器解释执行自己的代码。

import time
from threading import Thread,current_thread
m=100

def task():
    global m
    m1=m
    m=m1-1
    print(m,current_thread().name)

for line in range(100):
    t=Thread(target=task)
    t.start()

2.多线程的作用:

站在两个角度去看问题:

    - 四个任务, 计算密集型, 每个任务需要10s:
        单核:
            - 开启进程
                消耗资源过大
                - 4个进程: 40s

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

        多核:
            - 开启进程
                并行执行,效率比较高
                - 4个进程: 10s

            - 开启线程
                并发执行,执行效率低.
                - 4个线程: 40s



    - 四个任务, IO密集型, 每个任务需要10s:
        单核:
            - 开启进程
                消耗资源过大
                - 4个进程: 40s

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

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

            - 开启线程
                并发执行,执行效率高于多进程

                - 4个线程: 40s

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

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

#IO密集型
def work2():
    time.sleep(1)

if __name__ == '__main__':

    #测试计算密集型
    print(os.cpu_count()) #2
    start_time=time.time()
    list1=[]
    for line in range(6):
        p=Process(target=work1) #程序执行时间3.8562204837799072
        #p=Thread(target=work1) #程序执行时间0.9380536079406738
        list1.append(p)
        p.start()
    for p in list1:
        p.join()
    end_time=time.time()

    print(f'程序执行时间{end_time-start_time}')
    
    
    #测试IO密集型
    print(os.cpu_count())
    start_time=time.time()
    list1=[]
    for line in range(40):
        p=Process(target=work2)   #程序执行时间16.487942934036255
        # p = Thread(target=work2)  #程序执行时间1.3670780658721924
        list1.append(p)
        p.start()

    for p in list1:
        p.join()
    end_time=time.time()

    print(f'程序执行时间{end_time-start_time}')

在计算密集型情况下：使用多进程；IO密集型下，使用多线程；高效执行多个进程内多个IO密集型的程序：

3.死锁现象

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
卡住了。。。

4.递归锁

用于解决死锁问题。

Rlock：比喻成万能钥匙，可以提供给多个人去使用。但是第一个使用的时候，会对该锁做一个引用计数。只有引用计数为0，才能真正释放让另一个人去使用。

#递归锁
from threading import Lock,Thread,RLock
import time

mutex_a=mutex_b=RLock()

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(3):
    t=MyThread()
    t.start()

5.信号量：

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

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

from threading import Semaphore,Lock,current_thread,Thread
import time

sm=Semaphore(5)  #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()

互斥锁让20个线程一个一个执行完，信号量让20个线程5个5个执行完。

6.线程队列

线程Q：线程队列

FIFO：先进先出

LIFO：后进先出

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

#线程队列
import queue

#普通的线程队列：先进先出
q=queue.Queue()

q.put(1)
q.put(2)
print(q.get())  #1

#LIFO队列：后进先出
q=queue.LifoQueue()
q.put(1)
q.put(2)
print(q.get())  #2

#优先级队列
q=queue.PriorityQueue()
#若参数中传的是元组，会以元组中第一个数字参数为准
q.put(('a','wtf',4))
q.put(('a','wtt',3))
q.put(('a','wff',2))
print(q.get())  #('a', 'wff', 2)

'''
1.首先根据第一个参数判断ASCII表的数值大小
2.若相同，从左往右依次判断参数的数值大小
'''