上一章节内容汇总:
进程 multiprocess
Process ------ 进程 在python中创建一个进程的模块
start
daemon 守护进程
join 等待子进程执行结束
锁 Lock
acquire release
锁是一个同步控制的工具
如果同一时刻有多个进程同时执行一段代码,那么在内存中数据是不会发生冲突的。但是,如果涉及到文件,数据库机会发生资源冲突的问题。我们就需要用锁来把这段代码锁起来。任意一个进程执行了acquire之后,其他所有的进程都会在这里阻塞,等待一个release
信号量 semaphore
锁 + 计数器
set clear is set 控制对象的状态
wait 根据状态的不同执行效果也不同
状态是True ----> pass
状态是False ----> 阻塞
一般wait是和set clear 放在不同的进程中
set/clear 是负责控制状态
我可以在一个进程中控制另外一个或多个进程的运行情况。
IPC通信
队列 Queue
管道 PIPE
进程间通信——队列和管道(multiprocess.Queue、multiprocess.Pipe)
队列
from multiprocessing import Process,Queue
Queue([maxsize]) 创建共享的进程队列。 参数 :maxsize是队列中允许的最大项数。如果省略此参数,则无大小限制。 底层队列使用管道和锁定实现。
Queue([maxsize])
创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数,则无大小限制。底层队列使用管道和锁定实现。另外,还需要运行支持线程以便队列中的数据传输到底层管道中。
Queue的实例q具有以下方法:
q.get( [ block [ ,timeout ] ] )
返回q中的一个项目。如果q为空,此方法将阻塞,直到队列中有项目可用为止。block用于控制阻塞行为,默认为True. 如果设置为False,将引发Queue.Empty异常(定义在Queue模块中)。timeout是可选超时时间,用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用,将引发Queue.Empty异常。
q.get_nowait( )
同q.get(False)方法。
q.put(item [, block [,timeout ] ] )
将item放入队列。如果队列已满,此方法将阻塞至有空间可用为止。block控制阻塞行为,默认为True。如果设置为False,将引发Queue.Empty异常(定义在Queue库模块中)。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。
q.qsize()
返回队列中目前项目的正确数量。此函数的结果并不可靠,因为在返回结果和在稍后程序中使用结果之间,队列中可能添加或删除了项目。在某些系统上,此方法可能引发NotImplementedError异常。
q.empty()
如果调用此方法时 q为空,返回True。如果其他进程或线程正在往队列中添加项目,结果是不可靠的。也就是说,在返回和使用结果之间,队列中可能已经加入新的项目。
q.full()
如果q已满,返回为True. 由于线程的存在,结果也可能是不可靠的(参考q.empty()方法)。。
方法介绍
说明
队列可以在创建的时候指定一个容量
如果在程序运行的过程中,队列已经有了足够的数据,在put就会发生阻塞。
如果队列为空,在get就会发生阻塞。内存------制定容量
判断队列是否为空
from multiprocessing import Process,Queue
q = Queue()
print(q.empty())
执行输出:True
如果队列已满,在增加加值的操作,会被阻塞,知道队列有空余的。
from multiprocessing import Process,Queue
q = Queue(10) #创建一个只能放10个value的队列
for i in range(10):
q.put(i) #增加一个value
print(q.qsize()) #返回队列中目前的正确数量
print(q.full()) #如果q已满,返回为True
q.put(111) #在增加一个值
print(q.empty())
从结果中,可以看出,下面的操作q.put(111)之后的代码被阻塞了。
总结:
队列可以在创建的时候指定一个容量
如果在程序运行的过程中,队列已经有了足够的数据,在put就会发送阻塞
如果队列为空,在get就会发送阻塞
为什么要向队列的长度呢?是为了防止内存爆炸。
一个队列,不能无限制的存储。毕竟,内存是有限制的。
上面提到的put,get,full ,empty都是不准的。
因为在返回结果和在稍后程序中使用结果之间,队列中可能添加或删除了项目。在某些系统上,此方法可能引发NotImplementedError异常。
如果其他进程或线程正在往队列中添加项目,可能是不可靠的。也就是说,在返回和使用结果之间,队列中可能已经加入新的项目。
import time
from multiprocessing import Process,Queue
def wahaha(q):
print(q.get())
q.put(2) #增加数字2
if __name__ == '__main__':
q = Queue()
p = Process(target=wahaha,args=[q,])
p.start()
q.put(1) #增加数字1
time.sleep(0.1)
print(q.get())
先执行主进程的q.get(),在执行子进程的q.get()
在进程中使用队列可以完成双向通信
队列是进程安全的,内置了锁类保证队列中的每一个数据都不会被多个进程重复取
在同一个时刻,只能有一个进程来取值,它内部有一个锁的机制。那么另外一个进程就会被阻塞一会,但是阻塞的时间非常短队列能保证数据安全,同一个数据,不能被多个进程获取。
生产者消费者模型
解决数据供需不平衡的情况
from multiprocessing import Process,Queue
def producer(q,name,food):
for i in range(5):
print('{}生产了{}{}'.format(name,food,i))
if __name__ == '__main__':
q = Queue()
Process(target=producer,args=[q,'四川','蚂蚁上树']).start()
Process(target=producer,args=[q,'广东','龙虎斗']).start()
增加一个消费者
import time
import random
from multiprocessing import Process,Queue
def producer(q,name,food):
for i in range(5):
time.sleep(random.random()) #模拟生产时间
print('{}生产了{}{}'.format(name,food,i))
q.put('{}{}'.format(food,i)) #放入队列
def consumer(q,name):
for i in range(10):
food = q.get() #获取队列
time.sleep(random.random()) #模拟吃时间
print('{}吃了{}'.format(name,food))
if __name__ == '__main__':
q = Queue()
Process(target=producer,args=[q,'四川','麻婆豆腐']).start()
Process(target=producer,args=[q,'广东','八宝冬瓜盅']).start()
Process(target=consumer,args=[q,'John']).start()
注意:必须将消费者的range(10)修改为5,否则程序会卡住。为什么呢?因为队列已经是空的。在取机会阻塞这样才能解决供需平衡。
那么问题来了,如果一个消费者,吃的比较快呢?
在修改range值?太low 了,能者多劳嘛。不能使用q.empty(),他是不准确的。看下图,有可能一开始,队列就空了。
看下图的0.1更快
看下面的解决方案:
import time
import random
from multiprocessing import Process,Queue
def producer(q,name,food):
for i in range(5):
time.sleep(random.random()) #模拟生产时间
print('{}生产了{}{}'.format(name,food,i))
q.put('{}{}'.format(food,i)) #放入队列
def consumer(q,name):
for i in range(10):
food = q.get() #获取队列
time.sleep(random.random()) #模拟吃时间
print('{}吃了{}'.format(name,food))
if __name__ == '__main__':
q = Queue()#创建队列对象,如果不提供maxsize,则队列数无限制
p1 = Process(target=producer,args=[q,'四川','麻婆豆腐'])
p2 = Process(target=producer,args=[q,'广东','八宝冬瓜盅'])
p1.start() #启动进程
p2.start() #启动进程
Process(target=consumer,args=[q,'John']).start()
Process(target=consumer, args=[q, 'jenny']).start()
p1.join()
p2.join()
q.put('鲫鱼豆腐')
q.put('大酱肘子')
为什么要有2个done ?因为有两个2消费者
为什么要有2个join ? 因为必须要等厨师做完菜才可以。
最后输出2个done,表示通知2个顾客,菜已经上完了,顾客要结账了。
2个消费者,都会执行break。通俗的来讲,亲,您一共消费了xx元,请付款!
上面的解决方案,代码太长了,有一个消费者,就得done一次。
下面介绍JoinableQueue
JoinableQueue([maxsize])
创建可连接的共享进程队列。这就像是一个Queue对象,但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。
JoinableQueue的实例p除了与Queue对象相同的方法之外,还具有以下方法:
q.task_done()
使用者使用此方法发出信号,表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量,将引发ValueError异常。
q.join()
生产者将使用此方法进行阻塞,直到队列中所有项目均被处理。阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。
下面的例子说明如何建立永远运行的进程,使用和处理队列上的项目。生产者将项目放入队列,并等待它们被处理。
JoinableQueue的实例p除了与Queue对象相同的方法之外,还具有以下方法: q.task_done() 使用者使用此方法发出信号,表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量,将引发ValueError异常。 q.join() 生产者将使用此方法进行阻塞,直到队列中所有项目均被处理。阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。 下面的例子说明如何建立永远运行的进程,使用和处理队列上的项目。生产者将项目放入队列,并等待它们被处理。
JoinableQueue队列实现消费之生产者模型