死锁
- 指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程
from threading import Thread import time mutexA = Lock() mutexB = Lock() class MyThread(Thread): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print('\033[41m%s 拿到A锁\033[0m' %self.name) mutexB.acquire() print('\033[42m%s 拿到B锁\033[0m' %self.name) mutexB.release() mutexA.release() def func2(self): mutexB.acquire() print('\033[43m%s 拿到B锁\033[0m' %self.name) time.sleep(2) mutexA.acquire() print('\033[44m%s 拿到A锁\033[0m' %self.name) mutexA.release() mutexB.release() if __name__ == '__main__': for i in range(10): t = MyThread() t.start() Thread-1 拿到A锁 Thread-1 拿到B锁 Thread-1 拿到B锁 Thread-2 拿到A锁 #出现死锁，整个程序阻塞住 递归锁：
- 解决死递归方法 --- python提供了可重入锁RLock - RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源 - 区别是：递归锁可以连续acquire多次，而互斥锁只能acquire一次
from threading import Thread import time mutexA = mutexB = RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止 class MyThread(Theard): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print('\033[41m%s 拿到A锁\033[0m' %self.name) mutexB.acquire() print('\033[42m%s 拿到B锁\033[0m' %self.name) mutexB.release() mutexA.release() def func2(self): mutexB.acquire() print('\033[43m%s 拿到B锁\033[0m' %self.name) time.sleep(2) mutexA.acquire() print('\033[44m%s 拿到A锁\033[0m' %self.name) mutexA.release() mutexB.release() if __name__ == '__main__': for i in range(10): t=MyThread() t.start() 信号量 ----Semaphore
- 信号量也是一把锁，可以指定信号量为5，对比互斥锁同一时间只能有一个任务抢到锁去执行，信号量同一时间可以有5个任务拿到锁去执行，如果说互斥锁是合租房屋的人去抢一个厕所，那么信号量就相当于一群路人争抢公共厕所，公共厕所有多个坑位，这意味着同一时间可以有多个人上公共厕所，但公共厕所容纳的人数是一定的，这便是信号量的大小
from threading import Thraad import threading import time def func(): sm.acquire() print(f'{threading} get sm') time.sleep(2) sm.release() if __name__ =='__main__': sm = Semaphore(5) for i in ranfe(25): t = Thread(target= func) t.satrt() Semaphore管理一个内置的计数器， 每当调用acquire()时内置计数器-1； 调用release() 时内置计数器+1； 计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。 Event :
- 线程的一个关键特性是每个线程都是独立运行且状态不可预测 - threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
from threading import Event event.isSet() # 返回event的的状态值 event.wait() #如果 event.isSet()==False将阻塞线程 event.set()： #设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度； event.clear()：#恢复event的状态值为False。
#定时器，指定n秒后执行某操作 from threading import Timer def hello(): print('hello world') t = Timer(1,hello) t.start() # after 1 seconds, "hello, world" will be printed 线程Q[queue]:
class queue.Queue(maxsize) #队列： 先进先出
import queue q = queue.Queue() q.put('first') q.put('second') print(q.get()) print(q.get()) first second -class queue.LifoQueue(maxsize=0) # 堆栈 last in first out 先进后出
import queue q= queue.LifoQueue() q.put('first') q.put('second') print(q.get()) print(q.get()) #后进先出 second / first class queue.PriorityQueue(maxsize= 0) #优先级队列： 存储数据时可设置优先级队列 ，按照ascii 数字越小，越早执行
import queue q = queue.PriortyQueu() q.put((20,'q')) q.put((10,'b')) ptiny(q.get()) ptiny(q.get()) 1.首先根据第一个参数判断ascii表的数值大小 2.判断第个参数中的汉字顺序. 3.再判断第二参数中数字--> 字符串数字 ---> 中文 4.以此类推
多线程的作用: 站在两个角度去看问题: - 四个任务, 计算密集型, 每个任务需要10s: 单核: - 开启进程 消耗资源过大 - 4个进程: 40s - 开启线程 消耗资源远小于进程 - 4个线程: 40s 多核: - 开启进程 并行执行,效率比较高 - 4个进程: 10s - 开启线程 并发执行,执行效率低. - 4个线程: 40s - 四个任务, IO密集型, 每个任务需要10s: 单核: - 开启进程 消耗资源过大 - 4个进程: 40s - 开启线程 消耗资源远小于进程 - 4个线程: 40s 多核: - 开启进程 并行执行,效率小于多线程,因为遇到IO会立马切换CPU的执行权限 - 4个进程: 40s + 开启进程消耗的额外时间 - 开启线程 并发执行,执行效率高于多进程 - 4个线程: 40s
总结：
在计算密集型的情况下: 使用多进程 在IO密集型的情况下: 使用多线程 高效执行多个进程,内多个IO密集型的程序
