另外一个进程已经为 dpkg frontend lock 加锁_过来看看进程间常用的通讯方法！

Python中写多进程的程序，一般都使用multiprocessing模块。进程间数据是独立的，进程间通讯有多种方式，包括信号，管道，消息队列，信号量，共享内存，socket等。这里仅介绍三种常用通讯机制。

使用 multiprocessing.Queue()队列

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

设q为队列实例化对象：

q = Queue([maxsize])：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。设q为队列实例化对象：

常用方法：

1、q.get( [ block [ ,timeout ] ] ) ：返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。

2、q.get_nowait()：同q.get(False)方法。

3、q.put(item [, block [,timeout ] ] )：将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为True。如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。

4、q.qsize()：返回队列中目前项目的正确数量。此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。在某些系统上，此方法可能引发NotImplementedError异常。

5、q.empty() ：如果队列是空的，返回 True ，反之返回 False 。 由于多线程或多进程的环境，该状态是不可靠的。

6、q.full()：如果队列是满的，返回 True ，反之返回 False 。 由于多线程或多进程的环境，该状态是不可靠的。

7、q.close() ：关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。

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

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

示例代码：

from multiprocessing import Process, Queue

def p_func_1(q):
 q.put('zlyd')
 print('Queue full !' if q.full() else 'Queue no full ! ')
 q.put('guan zhu wo')
 print('Queue full !' if q.full() else 'Queue no full ! ')
 print("p_func_1 child process put data !")

def p_func_2(q):
 m1 = q.get()
 m2 = q.get()
 print('p_func_2 child process get data is ',m1,m2)
 print('Queue empty !' if q.empty() else 'Queue no empty ! ')

if __name__ == '__main__':
 q = Queue(2) # 实例化Queue对象, 先进先出，q = LifoQueue() 先入后出
 print("parent process")

 p = Process(target=p_func_1, args=(q,))
 m = Process(target=p_func_2, args=(q,))

 p.start()
 m.start()
 p.join()
 m.join()
 q.close()

注意：Queue创建的进程间的通信可以用于多进程，但不能用于进程池，如需进程池间通讯可用multiprocessing.Manager()中的Queue()

使用multiprocessing.Pipe()管道，优先考虑使用

Pipe([duplex])：在进程之间创建一条管道，并返回元祖（con1，con2），其中con1，con2表示管道两端连接的对象。

duplex：默认管道为全双工的，如果将duplex设置为False，该管道为单向管道，con1只能用于接收，con2只能由于发送。

管道常用方法：

1、con1.recv()：接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。

2、con1.send(obj)：通过连接发送对象。obj是与序列化兼容的任意对象。

3、con1.close()：关闭连接。如果conn1被垃圾回收，将自动调用此方法。

4、con1.fileno()：返回连接使用的整数文件描述符。

5、conn1.poll([timeout])：如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。

6、conn1.recv_bytes([maxlength])：接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。

7、conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收。

8、conn1.recv_bytes_into(buffer [, offset])：接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

示例代码：

from multiprocessing import Process, Pipe

def c_func(c_conn):
   c_conn.send([88, {"name": "zlyd"}, 'hello']) # 发送
   print("c_func 发送数据完成。")
response = c_conn.recv() # 等待接收
   print("c_func 接收的数据 : ", response) # 打印接收
   print('关闭通道。')
c_conn.close() ## 关闭pipe，两端都要关闭，正确管理，

def p_func(p_conn):
   rdata = p_conn.recv()
print('p_func 接收的数据 ：',rdata)
p_conn.send('ok ')
print('p_func 发送数据完成，关闭通道。')
p_conn.close() 

if __name__ == '__main__':
   parent_conn, child_conn = Pipe()  # 返回一对 Connection`对象  ``(conn1, conn2)` ， 分别表示管道的两端。
   print(type(parent_conn), type(child_conn)) # <class 'multiprocessing.connection.PipeConnection'>
   cobj = Process(target=c_func, args=(child_conn,))
pobj = Process(target=p_func, args=(parent_conn,))
cobj.start()
pobj.start()
cobj.join()
pobj.join()

注意：Queue和pipe只是实现了数据交互，并没实现数据共享，

使用multiprocessing.Manager()

Python中进程间共享数据，处理基本的queue，pipe和value + array外，还提供了更高层次的封装。

使用multiprocessing.Manager可以简单地使用这些高级接口。Manager()返回的manager对象控制了一个server进程，此进程包含的python对象可以被其他的进程通过proxies来访问。从而达到多进程间数据通信且安全。
Manager支持的类型有list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Queue, Value和Array。

Queue和Pipe只是实现了数据交互，并没实现数据共享，Manager()返回一个已启动的 SyncManager 管理器对象，这个对象可以用于在不同进程中共享数据。

示例代码：

from multiprocessing import Process, Manager,Lock

def f(d, l, i,lock):
 with lock: #  不加锁而操作共享的数据，数据会出乱，此例无用，示例而已
 if d['name'] == 'zlyd':
 d['count'] -= i
 l.append(i)

if __name__ == '__main__':
 lock = Lock()
 with Manager() as manager:
 d = manager.dict({'name':'zlyd','count':100}) # 字典类型的manager
 l = manager.list(range(5)) # 列表类型的manager
 p_list = []
 for i in range(10):
 p = Process(target=f, args=(d, l, i,lock))
 p.start()
 p_list.append(p)
 for res in p_list:
 res.join() # 等待进程退出，全部执行完成后再继续往下执行
 print('d-->',d)
 print('l-->',l)

更多精彩文章，在“栈了一堆”公众号里。

文章中有写错地方，请指出，希望大家多多评论，互相交流。