Python实现多进程间通信的方式有很多种，例如队列，管道等。
　　但是这些方式只适用于多个进程都是源于同一个父进程的情况。如果多个进程不是源于同一个父进程，只能用共享内存，信号量等方式，但是这些方式对于复杂的数据结构，例如Queue，dict，list等，使用起来比较麻烦，不够灵活。

1、进程间数据交换及共享

　　不同进程间内存是不共享的，要想实现两个进程间的数据交换.multiprocessing 里面的Queue与 queue中的Queue 使用方法差不多。一个是进程中的队列函数，一个是队列库中的队列工具。

A、如何实现两个进程间的数据传递：
第一步：单进程的队列工具的调用：（正常）

import queue,threading
def f(qq):
    qq.put("42,none,hello")

if __name__ =="__main__":
    q = queue.Queue()
    p = threading.Thread(target=f,args=(q,))
    p.start()
    print(q.get())
    p.join()
输出：
42,none,hello

第二步：父进程与子进程间的调用，数据共享会出错：（卡死）

import queue,threading,multiprocessing
def f(qq):
    qq.put("42,none,hello")

if __name__ == "__main__":
    q = queue.Queue()
    p = multiprocessing.Process(target=f,args=(q,))
    p.start()
    print(q.get())

 第三步：要想实现两个不通进程间的数据交换，修改如下：

import threading
import multiprocessing
def f(qq):
    qq.put("42,none,hello")

if __name__ =="__main__":
    q = multiprocessing.Queue()
    p = multiprocessing.Process(target=f,args=(q,)) #相当于克隆一份数据。
    p.start()
    print(q.get())
    p.join()
输出：
42,none,hello

B、使用Pipes实现两个进程间的数据传递

   Pipe() 函数：返回一个双由管默认为双相连接的连接对象（双向）。包括其他的pipe实现，都只是两个进程之间的游玩，我给你，你来接收 或者是你来，我接收。 当然也可以做成双工的状态。类似于打电话，双方可以进行数据交换，可发送，可接收。

import multiprocessing,os

def f(conn):
    conn.send([42,None,"hello"]) #4、发送信息
    conn.send("子进程发送信息给父进程：我的pid号是 %s" % os.getpid()) #5、第二次发送信息
    print(conn.recv())#9、接收父进程发送的信息
    conn.close()

if __name__ == "__main__":
    parent_conn,child_conn = multiprocessing.Pipe() #1、做pipe管道
    p = multiprocessing.Process(target=f,args=(child_conn,))#2、编写进程，调用f函数,并传入child_conn值
    p.start() #3、启动进程
    print(parent_conn.recv()) #6、接收信息。只能接收一次，可以使用while True 进行循环接收。
    print(parent_conn.recv()) #7、接收第二次信息
    parent_conn.send("父进程发信息给子进程：hello ,还好吗? 我的ID号是 %s" % os.getpid()) #8、给子进行发送信息
    p.join()#10、等待执行完成，一次性打印

输出：
[42, None, 'hello']
子进程发送信息给父进程：我的pid号是 11151
父进程发信息给子进程：hello ,还好吗? 我的ID号是 11150

 注意：两连接（）返回的对象代表管的两端。每个连接对象有send()和recv()方法。如果两个进程（或线程）试图同时读取或写入管道的同一端，则管道中的数据可能会损坏。当然，同时使用不同管端的过程不会有损坏的危险。

C、Manager  实现两个进程间的数据共享，也可以允许两个进程同时对内存中的数据修改。

Python通过Manager方式实现多个无关联进程共享数据。刚才A、B列举的两个例子，只能说的是实现了进程间的数据传递。如果要对两个进程间实现数据的共享，可以用使用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。

举例如下：

import  multiprocessing,os

def f(d,l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None

    l.append(os.getpid())
    print(l)

if __name__ == "__main__":
    with multiprocessing.Manager() as manager:
        d = manager.dict() #生成一个字典，可在多个进程间共享和传递
        l = manager.list(range(5)) #生成一个列表，可在多个进程间共享和传递
        p_list = []
        for i in range(10):
            p = multiprocessing.Process(target=f,args=(d,l))
            p.start()
            p_list.append(p)
        for res in p_list: #等待结果一次性输出
            res.join()
            
        print(d)
        print(l)
输出：
[0, 1, 2, 3, 4, 11928]
[0, 1, 2, 3, 4, 11928, 11929]
[0, 1, 2, 3, 4, 11928, 11929, 11930]
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931]
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931, 11932]
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931, 11932, 11934, 11933]
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931, 11932, 11934, 11933]
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931, 11932, 11934, 11933, 11935, 11936]
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931, 11932, 11934, 11933, 11935, 11936]
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931, 11932, 11934, 11933, 11935, 11936, 11937]
{0.25: None, 1: '1', '2': 2}
[0, 1, 2, 3, 4, 11928, 11929, 11930, 11931, 11932, 11934, 11933, 11935, 11936, 11937]

插入知识点：多进程锁：multiprocess.Lock。进程同步：如果两个进程没有使用lock来同步,则他们对同一个文件的写操作可能会出现混乱。

from  multiprocessing import Process,Lock

def f(l,i):
    l.acquire()
    try:
        print('hello world',i)

    finally:
        l.release()

if __name__ == "__main__":
    lock = Lock()

    for num in range(10):
        Process(target=f,args=(lock,num)).start()
输出：
hello world 0
hello world 1
hello world 2
hello world 3
hello world 4
hello world 5
hello world 6
hello world 7
hello world 8
hello world 9

  注意：如果不加锁，输出的时候，可能就出现混乱。

 

2、进程池的使用

Python中 multiprocessing.Pool()函数：进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。 

进程池中有两个方法：

  • apply   串行执行
  • apply_async  并行执行
from multiprocessing import Process,Pool,freeze_support
import time,os

def Foo(i):
    time.sleep(2)
    print("in process",os.getpid())
    return i + 100

def Bar(arg):
    print('-->exec done:',arg,os.getpid())

if __name__ == "__main__":
    freeze_support()
    pool = Pool(processes=3)#允许进程同时放入3个进程
    print("主进程",os.getpid())
    for i in range(10): #以下三种形式，可以测试验证一下，每次进程池只能允许3个进程打印。
        pool.apply_async(func=Foo,args=(i,),callback=Bar) #回调到Bar函数
        #pool.apply(func=Foo,args=(i,)) 
        #pool.apply_async(func=Foo, args=(i,))
    print('end')
    pool.close()
    pool.join() #进程池中进程执行完毕后在关闭，如果注释，那么程序会直接关闭。
输出：
主进程 13385
end
in process 13388
in process 13387
in process 13386
-->exec done: 101 13385
-->exec done: 100 13385
-->exec done: 102 13385
in process 13386
in process 13388
in process 13387
-->exec done: 104 13385
-->exec done: 105 13385
-->exec done: 103 13385
in process 13386
in process 13387
in process 13388
-->exec done: 107 13385
-->exec done: 108 13385
-->exec done: 106 13385
in process 13387
-->exec done: 109 13385