这就全都是了解的东西啦

GIL全局解释锁

gil本质就是一把互斥锁,既然是互斥锁,那他就能把并发运行变成串行,以此来控制同一时间内共享数据只能被一个任务所修改,进而保证数据安全

对于计算来说,cpu越多越好,但是对于I/O来说,再多的cpu都没什么用处,当然dui运行一个程序来说,随着cup的增多,执行效率肯定会有所提高

因为程序基本数不会是纯计算或者纯I/O,所以我们只能相对的去看一个程序到底是计算密集型还是i/o密集型,从而分析python的多线程用处

携程

主题是基于单线程来实现并发,即使用一个主线程的情况下并发.

cpu运行任务的时候,如果该任务发送了阻塞,或者执行时间过长,或者执行优先级更高的程序替代了它,才会切换至另外的任务

验证多线程的作用

多线程的作用:

站在两个角度去看问题:

比如我们这里有四个任务,是计算密集型的,每个任务完成需要十秒钟

单核:

进程:4个进程花费40秒

线程消耗的资源远小于进程:

4个线程任然花费40秒,因此这里我们选择线程

多核:

进程:并行执行,效率比较高

4个进程只需要10秒

线程,线程没法并发,执行效率低

4个线程需要40秒,因此这里我们选择使用进程

又来四个任务,IO密集型的,每个任务完成需要十秒钟

单核:

进程:4个进程花费40秒

线程消耗的资源远小于进程:

4个线程任然花费40秒,因此这里我们选择线程

(是不是有种似曾相识的感觉)

多核:

进程:4个进程要花费40秒在加上开启每个进程消耗的额外时间

线程消耗资源少:4个进程要花费的40秒,因此我们选择线程

因此在计算密集的情况下我们使用多进程,

而在IO密集的情况下我们使用多线程

死锁现象

所谓死锁:指的是两个或两个以上的进程或线程在执行过程中,因为资源总裁的一种相互等待的现象,若无外力作用,他们都无法推进下去.

解决方法:Rlock递归锁

'''
死锁现象(了解):

'''
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)  # 5个马桶
mutex = Lock()  # 5个马桶


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:线程队列 面试会问:FIFO

FIFO队列:先进先出

LIFO队列:后入先出

优先级队列:

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

2.判断第几个参数中的汉字顺序

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

4.以此类推