python进程间通信共享内存_python进程间通信 -- Queue

python进程间通信 -- Queue

多进程通信可使用 : 共享内存, 信号量, 服务进程管理(Server process manager), 队列Queue

queue.Queue是进程内线程安全队列

multiprocess.Queue是跨进程通信队列

若在multiprocess.Pool中则使用multiprocessing.Manager().Queue

一. queue.Queue 常用方法

Queue.qsize()：返回当前队列包含的消息数量

Queue.empty()：如果队列为空，返回True，反之False

Queue.full()：如果队列满了，返回True,反之False

Queue.get():获取队列中的一条消息，然后将其从列队中移除，可传参超时时长

Queue.get_nowait()：相当Queue.get(False),取不到值时触发异常：Empty

Queue.put():将一个值添加进数列，可传参超时时长

Queue.put_nowait():相当于Queue.get(False),当队列满了时报错：Full

二. 进程间通信使用multiprocess.Queue

#!/usr/bin/env python

# -*- coding: utf-8 -*-

# @File : test_process_comu2.py

# @Author: Wade Cheung

# @Date : 2018/12/10

# @Desc : 进程间通信

import asyncio

from multiprocessing import Process, Queue

def main_process():

queue = Queue()

p1 = Process(target=consume_process, args=(queue,))

p1.start()

p2 = Process(target=product_process, args=(queue,))

p2.start()

p2.join()

def product_process(queue):

thread_loop = asyncio.get_event_loop()

run_loop_thread = thread_loop.run_until_complete(async_product(queue))

async def async_product(queue):

while True:

queue.put('haha')

await asyncio.sleep(1)

def consume_process(queue):

while True:

print(queue.get())

if __name__ == '__main__':

main_process()

三. multiprocessing.Manager().Queue

#!/usr/bin/env python

# -*- coding: utf-8 -*-

# @File : test_process_comu1.py

# @Author: Wade Cheung

# @Date : 2018/12/10

# @Desc : 进程间通信

import time

from multiprocessing import Pool, Manager

def main_process():

queue = Manager().Queue()

p = Pool()

p1 = p.apply_async(consume_process, args=(queue,)) # apply_async 非阻塞

p2 = p.apply(product_process, args=(queue,))

p.close() # close后不会有新的进程加入到pool

p.join()

def product_process(queue):

while True:

queue.put('haha')

time.sleep(1)

def consume_process(queue):

while True:

print(queue.get())

if __name__ == '__main__':

main_process()

四.简单例子 --进程通信 + 动态添加协程

#!/usr/bin/env python

# -*- coding: utf-8 -*-

# @File : test_process_comu3.py

# @Author: Wade Cheung

# @Date : 2018/12/10

# @Desc : 进程通信, 动态添加协程 -- 简单例子

import asyncio

import threading

from multiprocessing import Process, Queue

def main_process():

queue = Queue()

p1 = Process(target=consume_process, args=(queue,)) # 消费者

p1.start()

p2 = Process(target=product_process, args=(queue,)) # 生产者进程

p2.start()

p2.join()

def product_process(queue):

# 次线程运行事件循环, 最终事件循环中运行async_product

thread_loop1 = asyncio.new_event_loop()

t = threading.Thread(target=start_loop, args=(thread_loop1,))

t.start()

# 主线程中运行事件循环, 动态添加协程

thread_loop2 = asyncio.get_event_loop()

thread_loop2.run_until_complete(create_product(queue, thread_loop1))

def start_loop(thread_loop1):

asyncio.set_event_loop(thread_loop1)

thread_loop1.run_forever()

async def create_product(queue, thread_loop1):

# 每秒创造一个product, 提交到次线程的事件循环中

i = 0

while True:

asyncio.run_coroutine_threadsafe(async_product(queue, str(i)), thread_loop1)

await asyncio.sleep(1)

i += 1

async def async_product(queue, i):

# 每秒将put into queue

while True:

queue.put(i + ' haha')

await asyncio.sleep(1)

def consume_process(queue):

while True:

print(queue.get())

if __name__ == '__main__':

main_process()

结果 :