进程间的通信

进程间的通信

在进程中的通信，像线程中的锁和使用的 queue 中的模块Queue 是不能用的,要用multiprocessing 提供的 Queue。

from multiprocessing import Process, Queue,Pool, Manager, Pipe

import time

def producer(queue):
    queue.put('sixkery')
    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 下的 Queue

注意：进程池间的通信不能用 Queue ，要用 Manger 里面的 queue

def producer(queue):
    queue.put('sixkery')
    time.sleep(2)

def consumer(queue):
    time.sleep(2)
    data = queue.get()
    print(data)


if __name__ == '__main__':
    
    queue = Manager().Queue(10) # 更改的地方
    pool = Pool(2)
    pool.apply_async(producer,args=(queue,))
    pool.apply_async(consumer,args=(queue,))
    
    pool.close()
    pool.join()

通信方式 Pipe

Pipe 是 queue 的子集。

def producer(pipe):
    pipe.send('sixkery')
    
def consumer(pipe):
    print(pipe.recv())


if __name__ == '__main__':
    # Pipe 只能用于两个进程中的通信
    receive_pipe, send_pipe = Pipe()

    my_producer = Process(target=producer,args=(send_pipe,))
    my_consumer = Process(target=consumer,args=(receive_pipe,))
    
    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()

• pipe 只能用于两个进程之间的通信

• pipe 的性能高于 queue ，queue 用于进程间的同步，里面有许多锁的机制

其他的通信方式

虽然说进程间的变量是完全隔离的，但是有时候我们希望进程像线程一样维护一个公共的模块，不能用共享变量来实现，就用共享内存模块来实现。

def add_data(a_dict,key,value):
    a_dict[key] = value


if __name__ == '__main__':
    process_dict = Manager().dict()

    first_process = Process(target=add_data,args=(process_dict,'sixkery1',22))
    second_process = Process(target=add_data,args=(process_dict,'sixkery2',23))

    first_process.start()
    second_process.start()

    first_process.join()
    second_process.join()

    print(process_dict)

# 运行结果：
{'sixkery2': 23, 'sixkery1': 22}

结果可以看到，这样的方式可以实现内存数据共享。