并发编程之进程间通信

目录

• 并发编程之进程间通信
  • 进程间通信--管道(multiprocessing.Pipe)
    • 进程间通信--队列（multiprocessing.Queue）
    • 队列的基础用法：
    • 代码实例
  • 生产者消费者模型
    • 为什么要使用生产者和消费者模式
    • 什么是生产者消费者模式

并发编程之进程间通信

进程间通信--管道(multiprocessing.Pipe)

conn1,conn2 = Pipe()
conn1.send('asfalfa')
print(conn2.recv())
双向通信，conn1发送的内容会被conn2接收，

from multiprocessing import Pipe,Process

def func(conn1,conn2):
    conn2.close()
    while True:
        try:
            msg = conn1.recv()
            print(msg)
        except EOFError:
            conn1.close()
            break

if __name__ == '__main__':
    conn1, conn2 = Pipe()
    p = Process(target=func,args=(conn1,conn2))
    p.start()
    for i in range(10):
        conn2.send('shabi')
    conn2.close()

进程间通信--队列（multiprocessing.Queue）

IPC(Inter-Process Communication)

创建共享的进程队列，Queue是多进程安全的队列，可以使用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（）方法）。。


#### 不常用方法
q.close() 
关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如，如果某个使用者正被阻塞在get（）操作上，关闭生产者中的队列不会导致get（）方法返回错误。

q.cancel_join_thread() 
不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。

q.join_thread() 
连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。

代码实例

'''
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()) #空了

生产者消费者模型

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

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

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

什么是生产者消费者模式

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

# 基础版本
from multiprocessing import Process,Queue
import time,random

def producer(name,food,q):
    for i in range(10):
        time.sleep(random.randint(1, 2))
        f = f'{name}生产了{food}{i}'
        print(f)
        q.put(f)

def consumer(name,q):
    while True:
        food = q.get()

        print(f'{name}吃了{food}')
        time.sleep(random.randint(1, 2))

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer,args=('大哥','牛奶',q))
    p2 = Process(target=producer,args=('二哥','面包',q))
    c1 = Process(target=consumer,args=('小红',q))
    c2 = Process(target=consumer,args=('小刚',q))
    p1.start()
    p2.start()
    c1.start()
    c2.start()
# 此时的问题是主进程永远不会结束，原因是：生产者p在生产完后就结束了，但是消费者c在取空了q之后，则一直处于死循环中且卡在q.get()这一步。

# 改良——终极版
'''
解决方式无非是让生产者在生产完毕后，往队列中再发一个结束信号，这样消费者在接收到结束信号后就可以break出死循环。
注意：结束信号None，不一定要由生产者发，主进程里同样可以发，但主进程需要等生产者结束后才应该发送该信号
'''
from multiprocessing import Process,Queue
import time,random

def producer(name,food,q):
    for i in range(10):
        time.sleep(random.randint(1, 2))
        f = f'\33[36m{name}生产了{food}{i}\33[0m'
        print(f)
        q.put(f)

def consumer(name,q):
    while True:
        food = q.get()
        print(f'\33[31m{name}吃了{food}\33[0m')
        time.sleep(random.randint(1, 2))
        q.task_done()

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer,args=('大哥','牛奶',q))
    p2 = Process(target=producer,args=('二哥','面包',q))
    p3 = Process(target=producer,args=('三哥','可乐',q))
    c1 = Process(target=consumer,args=('小红',q))
    c2 = Process(target=consumer,args=('小刚',q))
    p1.start()
    p2.start()
    p3.start()

    c1.daemon = True
    c2.daemon = True
    c1.start()
    c2.start()
    p1.join()
    p2.join()
    p3.join()
    q.join()

即便是使用线程，推荐做法也是将程序设计为大量独立的线程集合，通过消息队列交换数据。

这样极大地减少了对使用锁定和其他同步手段的需求，还可以扩展到分布式系统中。

但进程间应该尽量避免通信，即便需要通信，也应该选择进程安全的工具来避免加锁带来的问题。