112 python程序中的进程操作-进程之间进行通信（mulitiProcessing Queue队列）

一、进程间通信

IPC(Inter-Process Communication)

IPC机制：实现进程之间通讯

管道：pipe 基于共享的内存空间

队列：pipe+锁的概念--->queue

二、队列(Queue)

2.1 概念-----multiProcess.Queue

创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

Queue([maxsize])创建共享的进程队列。
参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。

底层队列使用管道和锁定实现。

2.2 Queue方法使用

2.2.1 q.get的使用：

  1. 是从队列里面取值并且把队列面的取出来的值删掉，没有参数的情况下就是是默认一直等着取值
  2. 就算是队列里面没有可取的值的时候，程序也不会结束，就会卡在哪里，一直等着 
    from multiprocessing import Queue

q = Queue() # 生成一个队列对象
# put方法是往队列里面放值
q.put('Cecilia陈')
q.put('xuchen')
q.put('喜陈')

# get方法是从队列里面取值
print(q.get())
print(q.get())
print(q.get())

q.put(5)
q.put(6)
print(q.get())

    Cecilia陈
    xuchen
    喜陈
    5

2.2.2 Queue(参数) +参数的使用：

  1. Queue加参数以后，参数是数值
  2. 参数实几就表示实例化的这个Queue队列可以放几个值
  3. 当队列已经满的时候，再放值,程序会阻塞，但不会结束 
    from multiprocessing import Queue
q = Queue(3)
q.put('Cecilia陈')
q.put('xuchen')
q.put('喜陈')
print(q.full()) # 判断队列是否满了 返回的是True/False
q.put(2) # 当队列已经满的时候，再放值,程序会阻塞，但不会结束

    True 队列已经满了

2.2.3 q.put(参数1，参数2，参数3，参数4)：

q.put(self, obj, block=True, timeout=None)

  1. self ：put就相当于是Queue里的一个方法，这个时候q.put就相当于是队列对象q来调用对象的绑定方法，这个参数可以省略即可
  2. obj：是我们需要往队列里面放的值
  3. block=True ：队列如果满了的话，再往队列里放值的话会等待，程序不会结束
  4. timeout=None：是再block这个参数的基础上的，当block的值为真的时候，timeout是用来等待多少秒，如果再这个时间里，队列一直是满的，那么程序就会报错并结束（Queue.Full异常） 
    from multiprocessing import Queue
q = Queue(3)
q.put('zhao',block=True,timeout=2)
q.put('zhao',block=True,timeout=2)
q.put('zhao',block=True,timeout=2)

q.put('zhao',block=True,timeout=5) # 此时程序将对等待5秒以后报错了

2.2.4 q.get(参数1，参数2，参数3，参数4):

q.get(self,block=True, timeout=None)

  1. self ：get就相当于是Queue里的一个方法，这个时候q.get就相当于是队列对象q来调用对象的绑定方法，这个参数可以省略即可
  2. block=True ：从队列q对象里面取值，如果娶不到值的话，程序不会结束
  3. timeout=None：是再block这个参数的基础上的，当block的值为真的时候，timeout是用来等待多少秒,如果再这个时间里，get取不到队列里面的值的话，那么程序就会报错并结束（queue.Empty异常） 
    from multiprocessing import Queue
q = Queue()
q.put('Cecilia陈')
print(q.get())

q.get(block=True,timeout=2) # 此时程序会等待2秒后，报错了，队列里面没有值了

2.2.5 block=False：

  1. 如果block的值是False的话，那么put方法再队列是满的情况下，不会等待阻塞，程序直接报错（Queue.Full异常）结束
  2. 如果block的值是False的话，那么get方法再队列里面没有值的情况下，再去取的时候，不会等待阻塞，程序直接报错（queue.Empty异常）结束

1.put()的block=False

from multiprocessing import Queue
q = Queue(2)
q.put('Cecilia陈')
q.put('喜陈')
print(q.full())

q.put('xichen',block=False) # 队列已经满了，我不等待了，直接报错

2.get()的block=Flase

from multiprocessing import Queue
q = Queue(2)
q.put('Cecilia陈')
q.put('喜陈')
print(q.get())
print(q.get())

print(q.get(block=False)) # 队列已经没有值了，我不等待了，直接报错

2.2.6 put_nowait()/get_nowait()

1.put_nowait() 相当于bolok=False，队列满的时候，再放值的时候，程序不等待，不阻塞，直接报错

from multiprocessing import Queue
q = Queue(2)
q.put('Cecilia陈')
q.put('喜陈')
print(q.full())

q.put_nowait('xichen') # 程序不等待，不阻塞，直接报错

2.get_nowait() 相当于bolok=False,当队列里没有值的时候，再取值的时候，程序不等待，不阻塞，程序直接报错

from multiprocessing import Queue
q = Queue(2)
q.put('Cecilia陈')
q.put('喜陈')
print(q.get())
print(q.get())
print(q.full())

q.get_nowait()# 再取值的时候，程序不等待，不阻塞，程序直接报错

三、代码实例

3.1 单看队列的存取数据用法

这个例子还没有加入进程通信，只是先来看看队列为我们提供的方法，以及这些方法的使用和现象。

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列
都是基于消息传递实现的,但是队列接口
'''

from multiprocessing import Queue
q=Queue(3)

#put ,get ,put_nowait,get_nowait,full,empty
q.put(3)
q.put(3)
q.put(3)
# q.put(3)   # 如果队列已经满了，程序就会停在这里，等待数据被别人取走，再将数据放入队列。
           # 如果队列中的数据一直不被取走，程序就会永远停在这里。
try:
    q.put_nowait(3) # 可以使用put_nowait，如果队列满了不会阻塞，但是会因为队列满了而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去，但是会丢掉这个消息。
    print('队列已经满了')

# 因此，我们再放入数据之前，可以先看一下队列的状态，如果已经满了，就不继续put了。
print(q.full()) #满了

print(q.get())
print(q.get())
print(q.get())
# print(q.get()) # 同put方法一样，如果队列已经空了，那么继续取就会出现阻塞。
try:
    q.get_nowait(3) # 可以使用get_nowait，如果队列满了不会阻塞，但是会因为没取到值而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去。
    print('队列已经空了')

print(q.empty()) #空了

3.2 子进程向父进程发送数据

这是一个queue的简单应用，使用队列q对象调用get函数来取得队列中最先进入的数据。

from multiprocessing import Process, Queue

def f(q,name,age):
    q.put(name,age)  #调用主函数中p进程传递过来的进程参数 put函数为向队列中添加一条数据。

if __name__ == '__main__':
    q = Queue() #创建一个Queue对象
    p = Process(target=f, args=(q,'Cecilia陈',18)) #创建一个进程
    p.start()
    print(q.get())
    p.join()

[‘Cecilia陈‘, 18]

四、生产者消费者模型

生产者: 生产数据的任务

消费者: 处理数据的任务

生产者--队列(盆)-->消费者

生产者可以不停的生产,达到了自己最大的生产效率,消费者可以不停的消费,也达到了自己最大的消费效率.

生产者消费者模型大大提高了生产者生产的效率和消费者消费的效率.

补充: queue不适合传大文件,通产传一些消息.

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

4.1 为什么要使用生产者和消费者模型

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

4.2 什么是生产者消费者模型

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

4.3 基于Queue队列实现的生产者消费者模型

from multiprocessing import Queue,Process

# 生产者
def producer(q,name,food):
    for i in range(3):
        print(f'{name}生产了{food}{i}')
        res = f'{food}{i}'
        q.put(res)

# 消费者
def consumer(q,name):
    while True:
        res = q.get(timeout=5)
        print(f'{name}吃了{res}')

if __name__ == '__main__':
    q = Queue() # 为的是让生产者和消费者使用同一个队列，使用同一个队列进行通讯
    p1 = Process(target=producer,args=(q,'Cecilia陈','巧克力'))
    c1 = Process(target=consumer,args=(q,'Tom'))

    p1.start()
    c1.start()

此时的问题是主进程永远不会结束，原因是：生产者p在生产完后就结束了，但是消费者c在取空了q之后，则一直处于死循环中且卡在q.get()这一步。

解决方式无非是让生产者在生产完毕后，往队列中再发一个结束信号，这样消费者在接收到结束信号后就可以break出死循环。

4.4 改良版----生产者消费者模型

注意：结束信号None，不一定要由生产者发，主进程里同样可以发，但主进程需要等生产者结束后才应该发送该信号

from multiprocessing import Queue,Process

def producer(q,name,food):
    for i in range(3):
        print(f'{name}生产了{food}{i}')
        res = f'{food}{i}'
        q.put(res)
    q.put(None) # 当生产者结束生产的的时候，我们再队列的最后再做一个表示，告诉消费者，生产者已经不生产了，让消费者不要再去队列里拿东西了

def consumer(q,name):
    while True:
        res = q.get(timeout=5)
        if res == None:break # 判断队列拿出的是不是生产者放的结束生产的标识，如果是则不取，直接退出，结束程序
        print(f'{name}吃了{res}')

if __name__ == '__main__':
    q = Queue() # 为的是让生产者和消费者使用同一个队列，使用同一个队列进行通讯
    p1 = Process(target=producer,args=(q,'Cecilia陈','巧克力'))
    c1 = Process(target=consumer,args=(q,'Tom'))

    p1.start()
    c1.start()

4.5 主进程在生产者生产结束以后，发送结束信号

使用这个方法的话，是很low的，有几个消费者就要在主进程中向队列中put几个结束信号

from multiprocessing import Queue,Process
import time,random

def producer(q,name,food):
    for i in range(3):
        print(f'{name}生产了{food}{i}')
        time.sleep((random.randint(1,3)))
        res = f'{food}{i}'
        q.put(res)
    # q.put(None) # 当生产者结束生产的的时候，我们再队列的最后再做一个表示，告诉消费者，生产者已经不生产了，让消费者不要再去队列里拿东西了

def consumer(q,name):
    while True:
        res = q.get(timeout=5)
        if res == None:break # 判断队列拿出的是不是生产者放的结束生产的标识，如果是则不取，直接退出，结束程序
        time.sleep((random.randint(1, 3)))
        print(f'{name}吃了{res}')

if __name__ == '__main__':
    q = Queue() # 为的是让生产者和消费者使用同一个队列，使用同一个队列进行通讯
    # 多个生产者进程
    p1 = Process(target=producer,args=(q,'Cecilia陈','巧克力'))
    p2 = Process(target=producer,args=(q,'xichen','冰激凌'))
    p3 = Process(target=producer,args=(q,'喜陈','可乐'))
    # 多个消费者进程
    c1 = Process(target=consumer,args=(q,'Tom'))
    c2 = Process(target=consumer,args=(q,'jack'))

    # 告诉操作系统启动生产者进程
    p1.start()
    p2.start()
    p3.start()

    # 告诉操作系统启动消费者进程
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()

    q.put(None) # 几个消费者put几次
    q.put(None)

五、JoinableQueue方法

创建可连接的共享进程队列。这就像是一个Queue对象，但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

5.1 方法介绍

JoinableQueue的实例p除了与Queue对象相同的方法之外，还具有以下方法：

q.task_done()：使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量，将引发ValueError异常。

q.join()：生产者将使用此方法进行阻塞，直到队列中所有项目均被处理。阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。

5.2 joinableQueue队列实现生产者消费者模型

from multiprocessing import Queue,Process,JoinableQueue
import time,random

def producer(q,name,food):
    for i in range(3):
        print(f'{name}生产了{food}{i}')
        # time.sleep((random.randint(1,3)))
        res = f'{food}{i}'
        q.put(res)
    # q.put(None) # 当生产者结束生产的的时候，我们再队列的最后再做一个表示，告诉消费者，生产者已经不生产了，让消费者不要再去队列里拿东西了
    q.join()

def consumer(q,name):
    while True:
        res = q.get(timeout=5)
        # if res == None:break # 判断队列拿出的是不是生产者放的结束生产的标识，如果是则不取，直接退出，结束程序
        # time.sleep((random.randint(1, 3)))
        print(f'{name}吃了{res}')
        q.task_done()#向q.join()发送一次信号,证明一个数据已经被取走了

if __name__ == '__main__':
    q = JoinableQueue() # 为的是让生产者和消费者使用同一个队列，使用同一个队列进行通讯
    # 多个生产者进程
    p1 = Process(target=producer,args=(q,'Cecilia陈','巧克力'))
    p2 = Process(target=producer,args=(q,'xichen','冰激凌'))
    p3 = Process(target=producer,args=(q,'喜陈','可乐'))
    # 多个消费者进程
    c1 = Process(target=consumer,args=(q,'Tom'))
    c2 = Process(target=consumer,args=(q,'jack'))

    # 告诉操作系统启动生产者进程
    p1.start()
    p2.start()
    p3.start()

    # 把生产者设为守护进程
    c1.daemon = True
    c2.daemon = True
    # 告诉操作系统启动消费者进程
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join() # 等待生产者生产完毕

    print('主进程')

    ### 分析
    # 生产者生产完毕--这是主进程最后一行代码结束--q.join()消费者已经取干净了,没有存在的意义了
    # 这是主进程最后一行代码结束,消费者已经取干净了,没有存在的意义了.守护进程的概念.

5.3 测试joinableQueue

from multiprocessing import Process,Queue,JoinableQueue

q = JoinableQueue()

q.put('zhao') # 放队列里一个任务
q.put('qian')

print(q.get())
q.task_done() # 完成了一次任务
print(q.get())
q.task_done() # 完成了一次任务
q.join() #计数器不为0的时候 阻塞等待计数器为0后通过

# 想象成一个计数器 :put +1   task_done -1

原文地址：https://www.cnblogs.com/xichenHome/p/11569046.html

时间： 2024-11-03 05:41:52

112 python程序中的进程操作-进程之间进行通信（mulitiProcessing Queue队列）的相关文章

Python程序中的线程操作-锁

Python程序中的线程操作-锁 一.同步锁 1.1多个线程抢占资源的情况 from threading import Thread import os,time def work(): global n temp=n time.sleep(0.1) n=temp-1 if __name__ == '__main__': n=100 l=[] for i in range(100): p=Thread(target=work) l.append(p) p.start() for p in l:

Python程序中的线程操作-concurrent模块

Python程序中的线程操作-concurrent模块 一.Python标准模块--concurrent.futures 官方文档:https://docs.python.org/dev/library/concurrent.futures.html 二.介绍 concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor:线程池,提供异步调用 ProcessPoolExecutor:进程池,提供异步调用 两者都实现相同的接口,该接口由抽象Execut

Python程序中的线程操作(线程池)-concurrent模块

目录 Python程序中的线程操作(线程池)-concurrent模块 一.Python标准模块--concurrent.futures 二.介绍 三.基本方法 四.ProcessPoolExecutor 五.ThreadPoolExecutor 六.map的用法 七.回调函数 Python程序中的线程操作(线程池)-concurrent模块 一.Python标准模块--concurrent.futures 官方文档:https://docs.python.org/dev/library/con

118 python程序中的线程操作-创建多线程

一.python线程的模块 1.1 thread和threading模块 thread模块提供了基本的线程和锁的支持 threading提供了更高级别.功能更强的线程管理的功能. 1.2 Queue模块 Queue模块允许用户创建一个可以用于多个线程之间共享数据的队列数据结构. 1.3注意模块的选择 避免使用thread模块 因为更高级别的threading模块更为先进,对线程的支持更为完善 而且使用thread模块里的属性有可能会与threading出现冲突: 其次低级别的thread模块的同

119 python程序中的线程操作-守护线程

一.守护线程 无论是进程还是线程,都遵循:守护xx会等待主xx运行完毕后被销毁.需要强调的是:运行完毕并非终止运行. 对主进程来说,运行完毕指的是主进程代码运行完毕 对主线程来说,运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕,主线程才算运行完毕 1.1 详解 主进程在其代码结束后就已经算运行完毕了(守护进程在此时就被回收),然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程),才会结束. 主线程在其他非守护线程运行完毕后才算运行完毕(守护线程在此时就被

121 python程序中的线程操作-队列queue

一.线程队列 queue队列:使用方法同进程的Queue一样 如果必须在多个线程之间安全地交换信息时,队列在线程编程中尤其有用. 重要: q.put():往队列里面放值,当参数block=Ture的时候,timeout参数将会有作用,当队列已经满了的时候,在往里面放值时,block为True程序将会等待timeout的时间,过了时间程序会报错,block如果为Flase时,程序不会等待直接报错 q.get():从队列里面取值,当参数block=Ture的时候,timeout参数将会有作用,当队列

120 python程序中的线程操作-锁

一.同步锁 1.1 多个线程抢占资源的情况 from threading import Thread,Lock x = 0 def task(): global x for i in range(200000): x = x+1 # t1 的 x刚拿到0 保存状态 就被切了 # t2 的 x拿到0 进行+1 1 # t1 又获得运行了 x = 0 +1 1 # 这就产生了数据安全问题. if __name__ == '__main__': # 使用的是操作系统的原生线程. t1 = Thread

122 python程序中的线程操作-concurrent模块

一.concurrent模块的介绍 concurrent.futures模块提供了高度封装的异步调用接口 ThreadPoolExecutor:线程池,提供异步调用 ProcessPoolExecutor:进程池,提供异步调用 ProcessPoolExecutor 和 ThreadPoolExecutor:两者都实现相同的接口,该接口由抽象Executor类定义. 二.基本方法 submit(fn, *args, **kwargs):异步提交任务 map(func, *iterables, t

121 Python程序中的线程操作-线程定时器

目录 一.线程定时器 二.用法 一.线程定时器 线程定时器也是定时器,就是定时之后开启一条线程 二.用法 ''' 线程定时器,就是规定时间后开启一条线程 ''' def task(): print('线程执行了') time.sleep(2) print('线程结束了') t = Timer(4,task) # 间隔时间, 功能函数 t.start() 原文地址:https://www.cnblogs.com/XuChengNotes/p/11553061.html