1.互斥锁
- 首先导入Lock模块
- 实例化一把锁
- 但是每次生成子进程的时候都会重新实例化一把锁,我们的目的是想让所有的子进程使用同一把锁,所以需要把锁传递给子进程在使用 锁名.acquire():开锁->所有子进程开始抢位置 锁名.release():关锁->位置排好了,开始执锁起来执行.
- join与互斥锁的区别:join是把所有的子进程代码变为串行的,而互斥锁则可以规定那几行代码变为串行
from multiprocessing import Process,Lock
import time
def foo(user,lock_new):
lock_new.acquire()
print(f"{user}--1")
time.sleep(1)
print(f"{user}--2")
time.sleep(1)
print(f"{user}--3")
lock_new.release()
if __name__ == '__main__':
lock_new = Lock()
for i in range(1,4):
p = Process(target=foo, args=(i,lock_new))
p.start()
2.队列与管道
- 互斥锁是基于硬盘资源的
- 队列和管道是基于内存的,multiprocessing模块提供了这个处理操作,也就是IPC,基于网络间进程通信的方式
- 队列是管道和锁的结合
- 队列需要遵守先进先出算法
- 还有就是就算不控制队列大小,他之后也会往里面塞数据
- 队列里面是放小数据的,不可以放类似视频的这种大数据
from multiprocessing import Queue
q = Queue(3)
q.put(1)
q.put(2)
q.put(3)
print(q.full())
print(q.get())
print(q.get())
print(q.get())
print(q.empty())
3.生产者消费者模型(Queue)
* 生产者消费者模型是根据队列来实现的
* 生产者把产生的消费者所需要的数据放入队列中,消费者再去队列中取出来
* 这一个知识点其实是队列的应用方式
from multiprocessing import Process, Queue
def producer(pro_name, q): # 生产者
for i in range(1,4):
res = f"{pro_name}生产的第{i}个蛋"
time.sleep(2)
print(res)
q.put(res)
def consumer(con_name, q):
while True: # 必须得死循环,因为你不知道生产者会生产多少东西,这个时候进程间通讯就起到很重要的作用
res = q.get()
if res is None:
break
print(f"{con_name}吃{res}")
if __name__ == '__main__':
q = Queue()
p1 = Process(target=producer,args=("xc",q))
c1 = Process(target=consumer,args=("wr",q))
p1.start()
c1.start()
p1.join()
q.put(None) # 在生产者结束生产之后,再传一个空值,因为消费者处于一直等待的状态,必须使用结束语句
c1.join()
print("打烊了")
4.生产者消费者模型（JoinableQueue）
from multiprocessing import Process,JoinableQueue
import time
def producer(pro_name, q): # 生产者
for i in range(3):
print(f"{pro_name}做的第{i+1}个包子")
res = f"{pro_name}做的第{i+1}个包子"
q.put(res)
# q.join() # 接受消费者取值的信号
def consumer(con_name, q):
while True:
res = q.get()
print(f"{con_name}吃了{res}")
q.task_done() # 发送消费者取值的信号，消费者把管道里面的数据取完了之后，生产者里面的join才会结束运行
# 这个其实就是这个数据要是接收完毕，就会给发送数据的一个消息，发送数据就可以执行完毕
if __name__ == '__main__':
q = JoinableQueue() # 这个方法 也就是可以join的 (也就是等待包含task_done的语句数据接收完，而不是执行完的时候)
p1 = Process(target=producer,args=('xc',q))
p2 = Process(target=producer,args=('xxc',q))
c1 = Process(target=consumer,args=('小狗',q))
c1.daemon = True # 因为本身消费者语句虽然接收完数据了，但是还是再运行，可是已经没有数据可以接受了，所以我们定义守护进程，让他伴随主进程结束而结束
p1.start()
p2.start()
c1.start()
p1.join()
p2.join()
q.join() # 写再这里和卸载生产者语句里面是一样的
print("打烊了")