1守护进程
定义：一个进程可以守护另一个进程
eg：如果b是a的守护进程，a是被守护的进程，a完了，b也shui随之完了，qq 接收到一个视频文件,于是开启了一个子进程来下载,如果中途退出了qq,下载任务就没必须要继续运行了
应用场景：父进程交给子进程一个任务，任务还没完成，父进程就结束了，子进程就没有继续执行的意义了
from multiprocessing import Process import time # 妃子的一生 def task(): print("入宫了.....") time.sleep(50) print("妃子病逝了......") if __name__ == '__main__': # 康熙登基了 print("登基了.....") # 找了一个妃子 p = Process(target=task) # 设置为守护进程 必须在开启前就设置好 p.daemon = True p.start() # 康熙驾崩了 time.sleep(3) print("故事结束了!")
2.互斥锁
定义：相互排斥的锁（如果这个资源被锁了，其他程序就无法执行了）
注：锁，并不是 把资源给锁起来了，只是在代码层面限制你的代码无法执行
why要锁：并发会带来资源的竞争问题，多比如说个进程同时操作同一个资源时，会导致数据错乱
解决方法：1.直接加join
弊端：1.会把原本并发的任务变成串行，虽然避免了数据的错乱，但效率降低了，这样的话，就没必开烤子了
2.原本多个进程是公平竞争，加join后，执行的顺序就定死了，不合理
2.给公共资源加互斥锁，这样依然是公平竞争，谁先抢到，谁先执行，父进程可做其他的事
锁与join的区别：
join：会固定死执行顺序，会造成父进程等子进程，他是吧进程的任务全部串行
锁：还是公平竞争，谁先抢到谁先执行，锁可以锁任意代码，一行代码也行，可以自己调粒度
颗粒： 一种级别，颗粒越大锁住的代码越多，效率越低，反之亦然。
注：1.一次acquire对应一次release，不要把锁给锁了，这样程序就无法执行了
2.想要保护数据安全，必须保证所有进程使用同一把锁
from multiprocessing import Process,Lock import time,random def task1(lock): # 要开始使用了 上锁 lock.acquire() #就等同于一个if判断 print("hello iam jerry") time.sleep(random.randint(0, 2)) print("gender is boy") time.sleep(random.randint(0, 2)) print("age is 15") # 用完了就解锁 lock.release() def task2(lock): lock.acquire() print("hello iam owen") time.sleep(random.randint(0,2)) print("gender is girl") time.sleep(random.randint(0,2)) print("age is 48") lock.release() def task3(lock): lock.acquire() print("hello iam jason") time.sleep(random.randint(0,2)) print("gender is women") time.sleep(random.randint(0,2)) print("age is 26") lock.release() if __name__ == '__main__': lock = Lock() p1 = Process(target=task1,args=(lock,)) p2 = Process(target=task2,args=(lock,)) p3 = Process(target=task3,args=(lock,)) p1.start() # p1.join() p2.start() # p2.join() p3.start() # p3.join() # print("故事结束!") # 锁的伪代码实现 # if my_lock == False: # my_lock = True # #被锁住的代码 my_lock = False 解锁
3.ipc
定义：IPC是进程间的通询，也就是一个进程把数据交给另一个进程，进程间内存相互隔离，想要通讯要用ipc
方式：1.管道：只能单向通讯，数据都是二进制，
2.文件：在硬盘上创建共享文件，数据量几乎没有限制，但是速度慢
3.socket：编程复杂度高，
4共享内存：
1.Manager:它提供很多数据结构 list dict 等，它提供的数据结构具备进程间共享的特点
注：Manager创建的一些数据结构是不带锁的，可能会出问题
from multiprocessing import Process,Manager,Lock import time def task(data,l): l.acquire() num = data["num"] # time.sleep(0.1) data["num"] = num - 1 l.release() if __name__ == '__main__': # 让Manager开启一个共享的字典 m = Manager() data = m.dict({"num":10}) l = Lock() for i in range(10): p = Process(target=task,args=(data,l)) p.start() time.sleep(2) print(data)
2.Queue队列
队列：队列是一种特殊的数据结构，先进先出，就像排队
堆栈：先进后出，就像衣橱，桶装薯片
扩展：函数嵌套调用时 指执行顺序先进后出， 称之为函数栈
调用函数时，函数入栈，函数结束就出栈
from multiprocessing import Queue # 创建队列 不指定maxsize 则没有数量限制 q = Queue(3) # 存储元素 # q.put("abc") # q.put("hhh") # q.put("kkk") # print(q.get()) # q.put("ooo") # 如果容量已经满了,在调用put时将进入阻塞状态 直到有人从队列中拿走数据有空位置 才会继续执行 #取出元素 # print(q.get())# 如果队列已经空了,在调用get时将进入阻塞状态 直到有人从存储了新的数据到队列中 才会继续 # print(q.get()) # print(q.get()) #block 表示是否阻塞 默认是阻塞的 # 当设置为False 并且队列为空时 抛出异常 q.get(block=True,timeout=2) # block 表示是否阻塞 默认是阻塞的 # 当设置为False 并且队列满了时 抛出异常 # q.put("123",block=False,) # timeout 表示阻塞的超时时间 ,超过时间还是没有值或还是没位置则抛出异常 仅在block为True有效
4.生产者消费者 模型
定义：解决 产生数据与处理数据的 问题的一种套路
生产者与消费者的问题：他们两者处理速度不平衡，一方快一放慢，导致一方需要等待另一方
解决问题的思路：
原本双方是耦合在一起，消费必须等待生产者生成完毕，再开始处理，反之亦然；
现在，可以把双方分开，一方负责生产，一方负责处理，这样数据就不能直接交互了，双方需要一个共同的容器。然后生产者放入容器，消费者取出数据。这样就解决了两者处理速度不平衡的问题，都可以自己做自己的，无需等待。
def eat(q): for i in range(10): # 要消费 rose = q.get() time.sleep(random.randint(0, 2)) print(rose,"吃完了!") # 生产任务 def make_rose(q): for i in range(10): # 再生产 time.sleep(random.randint(0, 2)) print("第%s盘青椒肉丝制作完成!" % i) rose = "第%s盘青椒肉丝" % i # 将生成完成的数据放入队列中 q.put(rose) if __name__ == '__main__': # 创建一个共享队列 q = Queue() make_p = Process(target=make_rose,args=(q,)) eat_p = Process(target=eat,args=(q,)) make_p.start() eat_p.start()