进程间的通信

★管道
Python中的管道有两种工作方式：
1，单项(半双工)
一端只能发送数据，另一端只能接收数据。
2，双向(全双工)
两端都既能发送数据又能接收数据，一端发送的数据只能由另一端接收。

标准库模块multiprocessing中提供了一个函数Pipe()，其返回值是一个元组，元组中包含两个对象，
分别表示管道两端的连接。
调用函数Pipe()时，如果不传入参数或传入参数为True，管道的工作方式为双向(全双工)；
如果传入的参数为False，管道的工作方式为单向(半双工)，其中，对于返回的元组，第一个
连接对象只能接收数据，第二个连接对象只能发送数据。

对于管道两端的连接对象，主要由两个方法：
1，send(self,obj)
用于将参数obj指定的对象发送到管道。
2，recv(self)
用于从管道中接收对象。

from multiprocessing import Pipe

#conn1和conn2为管道的两端。
conn1, conn2 = Pipe() #Pipe()或Pipe(True)为全双工

conn1.send('conn1第1次发送的数据')
conn1.send('conn1第2次发送的数据')

conn2.send('conn2第1次发送的数据')
conn2.send('conn2第2次发送的数据')

print(conn1.recv()) 
print(conn1.recv()) 

print(conn2.recv()) 
print(conn2.recv()) 


#测试半双工
c1, c2 = Pipe(False)  #Pipe(False)为半双工。c1只能接收，c2只能发送。

c2.send('c2发送的数据')
print(c1.recv())    

# c1.send('c1发送的数据') #OSError: connection is read-only

#【1】进程间的通信之管道

管道是实现进程间通信的常见方式之一。

from multiprocessing import Process, Pipe
import os, time, random

#发送数据的子进程执行
def send_data(conn):
    print('发送数据的子进程%d启动' % os.getpid())

    for obj in list(range(1, 10)):
        print('发送数据：%s' % obj)
        conn.send(obj)
        time.sleep(random.random() * 3)

    print('发送数据：None')
    conn.send(None)

    print('发送数据的子进程%d结束' % os.getpid())
    
#接收数据的子进程执行
def recv_data(conn):
    print('接收数据的子进程%d启动' % os.getpid())

    while True:
        item = conn.recv()
        if item is None:
            print('接收数据：None')
            break
        print('接收数据：%s' % item)
        time.sleep(random.random() * 3)

    print('接收数据的子进程%d结束' % os.getpid())

print('父进程%d启动' % os.getpid())

cr, cs = Pipe(False) #半双工

ps = Process(target=send_data, args=(cs,))  #args指定target接收的参数。
pr = Process(target=recv_data, args=(cr,))

ps.start()
pr.start()

#两个子进程阻塞父进程
ps.join()
pr.join()

print('父进程%d结束' % os.getpid())

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([1, {"name":"Li"}, 'hi'])
    response=conn.recv()
    print("response",response)
    conn.close()
    print("c_conn传入子进程后的id:",id(conn))

if __name__ == '__main__':

    p_conn, c_conn = Pipe() #全双工
    print("c_conn在主进程中的id:",id(c_conn))
    p = Process(target=f, args=(c_conn,))
    p.start()
    print(p_conn.recv())   
    p_conn.send("hello!")
    p.join()

#【2】进程间的通信之Manager

如果想要实现进程间的通信，Manager也是常见的实现方式之一。
与共享内存相比，Manager更加灵活，因为它可以支持多种对象类型。此外，Manager还可以通过网络
被不同的计算机上的进程所共享。但是，Manager的速度比共享内存慢。

from multiprocessing import Process, Manager

#子进程执行操作
def f(d,l):
    d[1] = 18
    d['2'] = 56
    l.reverse()  #列表反转
if __name__ == '__main__':
    manager = Manager()

    #通过Manager创建一个用于进程间通信的字典
    d = manager.dict()
    #通过Manager创建一个用于进程间通信的列表
    l = manager.list(range(5))

    p = Process(target=f,args=(d,l,))
    p.start()
    p.join()  #阻塞父进程

    print(d)
    print(l)

 #【3】进程间的通信之共享内存

参考：另一篇博客。

 #【4】进程间的通信之进程队列（multiprocessing.Queue()）

#import queue
#import time
import multiprocessing
q = multiprocessing.Queue()


def foo(q, n):
    q.put(1)
    q.put(2)
    print("子进程：", id(q))


if __name__ == '__main__':
    #q=queue.Queue() #<--错误；这个为线程队列，不能在进程间共享队列元素。
    procList = []
    print("主进程：", id(q))
    for i in range(2):
        p = multiprocessing.Process(target=foo, args=(q, i))#此处用进程队列。
        p.start()
        procList.append(p)
    #q.start()
    for p in procList:#阻塞主進程
        p.join()
    #time.sleep(5)
    print(q.get())
    print(q.get())