并发编程之进程通信（队列和管道）

合集 - 并发编程炒大饼(26)

1.并发编程之操作系统引入2024-01-212.并发编程之多进程理论篇2024-01-213.并发编程之多进程操作篇2024-01-214.并发编程之僵尸进程、孤儿进程和守护进程2024-01-215.并发编程之进程互斥锁2024-01-21

6.并发编程之进程通信（队列和管道）2024-01-21

7.并发编程之进程通信（生产消费模型）2024-01-218.并发编程之多线程理论篇2024-01-219.并发编程之多线程操作篇2024-01-2110.并发编程之守护线程2024-01-2111.并发编程之线程的互斥锁2024-01-2112.并发编程之GIL解释器锁2024-01-2113.并发编程之死锁和递归锁2024-01-2114.并发编程之信号量Semaphore2024-01-2115.并发编程之Event事件2024-01-2116.并发编程之条件Condition2024-03-0317.并发编程之定时器2024-03-0318.并发编程之线程queue2024-03-0319.并发编程之Python标准模块--concurrent2024-03-0320.并发编程之协程理论2024-03-0321.并发编程之Greenlet模块2024-03-0322.并发编程之Gevent模块2024-03-0323.并发编程之asyncio模块2024-03-0324.并发编程之IO模型2024-03-0325.并发编程补充：基于多进程实现并发的套接字通信2024-03-0326.并发编程补充：基于多线程实现并发的套接字通信2024-03-03

收起

引言

什么是进程间通信

进程间通信（Inter-Process Communication, IPC）是指两个或多个进程之间进行信息交换的过程。它是一种计算机编程技术，用于在不同进程之间共享数据和资源。

如何实现进程间通信

借助于消息队列，进程可以将消息放入队列中，然后由另一个进程从队列中取出。这种通信方式是非阻塞的，即发送进程不需要等待接收进程的响应即可继续执行。

multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的。

队列（推荐使用）

什么是队列（管道加锁, 先进先出）

队列是一种线程安全的数据结构，它支持在多线程环境中高效地实现生产者-消费者模型。

队列的特性是先进先出（First-In-First-Out, FIFO），即先插入队列的数据将先被取出。而堆栈是一种后进先出（Last-In-First-Out, LIFO）的数据结构，与队列相反，最后插入的数据将首先被取出。

创建队列的类（底层就是以管道和锁定的方式实现）：

# 导入模块
from multiprocessing import Queue
# 创建一个队列对象
q = Queue([maxsize])  # 多进程可以使用Queue进行数据传递
# 参数介绍
maxsize               # 是队列中允许最大项, 省略则无大小限制

主要方法介绍：

方法	功能
q.put( )	向队列中传入数据,可选参数 : blocked(锁定状态)和timeout(超时时间)。如果blocked为True（默认值), 并且timeout为正值, 该方法会阻塞timeout指定的时间, 直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常
q.get( )	从队列读取走一个元素, 有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常
q.get_nowait( )	同q.get(blocked=False)
q.put_nowait( )	同q.put(blocked=False)
q.empty( )	调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目
q.full( )	调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走
q.qsize( )	返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样

其他方法(了解)：

方法	功能
q.cancel_join_thread( )	不会在进程退出时自动连接后台线程, 可以防止join_thread()方法阻塞
q.close( )	关闭队列, 防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误
q.join_thread( )	连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为

队列的使用

'''
multiprocessing模块支持进程间通信的两种主要形式:管道和队列
都是基于消息传递实现的,但是队列接口
'''
from multiprocessing import Queue
 
q = Queue(3)  # 创建一个队列,设置最大项为3
 
q.put({"name": "xiao"})  # 放入一个字典
q.put([1, 2, 3, 4, 5])  # 放入一个列表
q.put("shawn")  # 放入一个字符串
try:
    # q.put(1777,block=True,timeout=3)
    q.put(1777, block=False)  # 放入一个整形,并设置队列已满立马抛异常
except Exception:
    print("队列已满")
 
print(q.get())  # 取一个值
print(q.get())  # 2
print(q.get())  # 3
try:
    # print(q.get(block=True,timeout=3))
    print(q.get(block=False))  # 取一个值,队列为空立马抛出异常
except Exception:
    print("队列已空")
 
# 队列已满
# {'name': 'xiao'}
# [1, 2, 3, 4, 5]
# shawn
# 队列已空

管道（不推荐使用，了解即可）

什么是管道

一个进程将一个数据放入管道内(共享内存), 另一个进程从管道内取出数据进行处理

创建队列的类

# 导入模块
from multiprocessing import Pipe
#创建管道的类：
Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道
# 参数介绍
dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。

主要方法介绍：

方法	功能
conn1.recv()	接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
conn1.send(obj)	通过连接发送对象。obj是与序列化兼容的任意对象

其他方法(了解)：

方法	功能
conn1.close()	关闭连接。如果conn1被垃圾回收，将自动调用此方法
conn1.fileno()	返回连接使用的整数文件描述符
conn1.poll([timeout])	如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。
conn1.recv_bytes([maxlength])	接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。
conn.send_bytes(buffer [, offset [, size]])	通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收
conn1.recv_bytes_into(buffer [, offset])	接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

管道的使用

基于管道实现进程间通信（与队列的方式是类似的，队列就是管道加锁实现的）

from multiprocessing import Process,Pipe
 
import time,os
def consumer(p,name):
    left,right=p
    left.close()
    while True:
        try:
            baozi=right.recv()
            print('%s 收到包子:%s' %(name,baozi))
        except EOFError:
            right.close()
            break
def producer(seq,p):
    left,right=p
    right.close()
    for i in seq:
        left.send(i)
        # time.sleep(1)
    else:
        left.close()
if __name__ == '__main__':
    left,right=Pipe()
    c1=Process(target=consumer,args=((left,right),'c1'))
    c1.start()
    seq=(i for i in range(10))
    producer(seq,(left,right))
    right.close()
    left.close()
    c1.join()
    print('主进程')

注意：生产者和消费者都没有使用管道的某个端点，就应该将其关闭，如在生产者中关闭管道的右端，在消费者中关闭管道的左端。如果忘记执行这些步骤，程序可能再消费者中的recv*()*操作上挂起。管道是由操作系统进行引用计数的,必须在所有进程中关闭管道后才能生产EOFError异常。因此在生产者中关闭管道不会有任何效果，付费消费者中也关闭了相同的管道端点。

管道编写进程交互

管道可以用于双向通信，利用通常在客户端/服务器中使用的请求／响应模型或远程过程调用，就可以使用管道编写与进程交互的程序

from multiprocessing import Process,Pipe
 
import time,os
def adder(p,name):
    server,client=p
    client.close()
    while True:
        try:
            x,y=server.recv()
        except EOFError:
            server.close()
            break
        res=x+y
        server.send(res)
    print('server done')
if __name__ == '__main__':
    server,client=Pipe()
 
    c1=Process(target=adder,args=((server,client),'c1'))
    c1.start()
 
    server.close()
 
    client.send((10,20))
    print(client.recv())
    client.close()
 
    c1.join()
    print('主进程')
#注意：send()和recv()方法使用pickle模块对对象进行序列化。