引言
进程间通信与线程间通信有相同的地方，也有不同的地方。threading模块中用于线程同步的机制在进程中是不能够使用的，queue模块中的Queue类也是不能用的。举个例子：
from multiprocessing import Process
import time
from queue import Queue
def producer(queue):
queue.put('a')
time.sleep(2)
def consumer(queue):
time.sleep(2)
data = queue.get()
print(data)
if __name__ == "__main__":
queue = Queue(10)
my_producer = Process(target=producer, args=(queue,))
my_consumer = Process(target=consumer, args=(queue,))
my_producer.start()
my_consumer.start()
my_producer.join()
my_consumer.join()
# 执行结果
# TypeError: can't pickle _thread.lock objects
可以看出，运行是报错了，虽然不能使用queue模块，但是multiprocessing模块提供了其他的方法。
进程通信
Queue
multiprocessing模块提供了适合进程通信的Queue类，用法和queue模块中的Queue一模一样，只是导入的包不一样。
from multiprocessing import Process, Queue
import time
def producer(queue):
queue.put('a')
time.sleep(2)
def consumer(queue):
time.sleep(2)
data = queue.get()
print(data)
if __name__ == "__main__":
queue = Queue(10)
my_producer = Process(target=producer, args=(queue,))
my_consumer = Process(target=consumer, args=(queue,))
my_producer.start()
my_consumer.start()
my_producer.join()
my_consumer.join()
值得注意的是：对于multiprocessing模块中提供的进程池Pool类，Queue是不支持的！
Manager
multiprocessing模块中的Manager类也可用于进程同步且，更为强大，将其实例化之后，其中也存在Queue，用法相同，并且可以用于multiprocessing模块中提供的进程池Pool类。
除此之外，Manager里面提供了list、dict、Value、Semaphore、Lock、Condition等用于进程同步的机制。举个dict的例子：
from multiprocessing import Process
from multiprocessing import Manager
def add_data(p_dict, key, value):
p_dict[key] = value
if __name__ == "__main__":
progress_dict = Manager().dict()
first_progress = Process(target=add_data, args=(progress_dict,'key1','10'))
second_progress = Process(target=add_data, args=(progress_dict,'key2','11'))
first_progress.start()
second_progress.start()
first_progress.join()
second_progress.join()
print(progress_dict)
# 执行结果
# {'key1': '10', 'key2': '11'}
可以看到，两个进程同时操作同一个变量，确实都成功了。如果讲Manager().dict()换成普通的dict()，结果打印出来一定是空字典。
Pipe
pipe是简化办的Queue，只能用于两个进程之间通信，不适用于多个，优点是速度相对于Queue更快。
from multiprocessing import Process, Pipe
import time
def producer(pipe):
pipe.send('send to you')
time.sleep(2)
data = pipe.recv()
print('In producer recv:', data)
def consumer(pipe):
time.sleep(2)
data = pipe.recv()
print('In consumer recv:',data)
pipe.send('I recv')
if __name__ == "__main__":
receive_pipe, send_pipe = Pipe()
my_producer = Process(target=producer, args=(receive_pipe,))
my_consumer = Process(target=consumer, args=(send_pipe,))
my_producer.start()
my_consumer.start()
my_producer.join()
my_consumer.join()
# 执行结果
# In consumer recv: send to you
# In producer recv: I recv
Pipe管道构建的时候返回两个对象，这两个对象之间可以通过send和recv方法传递数据。
总结
- 进程通信有Queue、Manager和Pipe三种方法。
