Python 使用异步IO的进程间通信？

我有一组CPU密集型进程，它们偶尔会相互依赖以继续进行。大概是

def run():
  while True:
    do stuff
    wake up some other process
    wait for some other process to wake me up
    do stuff

---

在每个进程中，我希望使用async，以便在其他进程等待唤醒时，始终可以运行

run

的实例。查看

asyncio

文档，我看到的“高级API”部分中唯一的IPC选项使用套接字。我更愿意使用管道，看起来我可能可以使用低级API，但是文档中充满了警告，如果您只是在编写应用程序，那么使用它是一个错误。有人能在这里介绍一下惯用的做法吗？（而且，速度也是一个重要因素，因此，如果有一些不太惯用但性能更高的东西，我也想了解一下这个选项。）

我想提到这个库，因为我在我的一个项目中成功地使用了它。它为包含IPC的

多处理

原语（如

过程

，

管道

，

锁定

，

队列

等）提供了一个anync接口。它使用线程池来实现这一点：

    ...
    @staticmethod
    def coro_maker(func):
        def coro_func(self, *args, loop=None, **kwargs):
            return self.run_in_executor(
                getattr(self, func), *args, loop=loop, **kwargs
            )

        return coro_func

但老实说，很大程度上取决于所解决的问题，取决于并发执行的任务，因为异步方法中密集的IPC本身由于事件循环的开销不如同步方法有效，线程池等。有时最好使所有IPC操作同步，并将其全部放在单独的线程中。同样，这完全取决于问题和环境。下面是一个远非全面的基准，但它可以给出一个正在解决的问题的大致情况（缓冲区的密集交换）

注意：我写过队列和SimpleQueue之间的区别

---

使用asyncio您最好的选择可能是使用套接字，因为这是最受支持的。您可以使用域套接字来避免（本地）TCP/IP的开销。管道的唯一公共异步接口是生成子流程。但是，尽管您可以与子流程异步通信，但在子流程内部却没有与父流程异步通信的功能。这太可惜了。我特别惊讶的是，

multiprocessing

中没有异步版本的数据结构。我认为有一个

aiommultiprocessing

，但AFAIR它只是使用一个线程池在引擎盖下运行真正的多处理，并在顶部提供一个“异步”API。由于多处理本身会启动多个线程，因此您需要为这两个线程的资源付费。在每个进程中，我希望使用xxx，以便在其他线程等待唤醒时，我始终可以运行一个实例。。我会用互斥、锁、信号量或任何其他同步工具替换xxx，但肯定不是asyncio。为什么您认为asyncio是这里的正确工具？@SergeBallesta每个线程都会周期性地阻塞等待来自另一个进程的数据。我希望该线程只有在数据可用时才会唤醒。

线程

不使用先发制人的线程吗？这似乎会导致大量的循环浪费（更不用说，为了显式地管理锁，必须更仔细地编写代码）。你为什么说这里使用

asyncio

不合适？

Sync SimpleQueue:  1.4309470653533936
AioSimpleQueue:  12.32670259475708
AioQueue:  14.342737436294556
AioPipe:  11.747064590454102
subprocess pipe stream:  7.344956159591675
socket stream:  4.360717058181763

# main.py
import sys
import time
import asyncio
import aioprocessing as ap
import multiprocessing as mp
import proc

count = 5*10**4
data = b'*'*100


async def sync_simple_queue_func():
    out_ = mp.SimpleQueue()
    in_ = mp.SimpleQueue()
    p = ap.AioProcess(target=proc.start_sync_queue_func, args=(out_, in_))
    p.start()

    begin_ts = time.time()
    for i in range(count):
        out_.put(data)
        res = in_.get()
    print('Sync SimpleQueue: ', time.time() - begin_ts)
    out_.put(None)


async def simple_queue_func():
    out_ = ap.AioSimpleQueue()
    in_ = ap.AioSimpleQueue()
    p = ap.AioProcess(target=proc.start_queue_func, args=(out_, in_))
    p.start()

    begin_ts = time.time()
    for i in range(count):
        await out_.coro_put(data)
        res = await in_.coro_get()
    print('AioSimpleQueue: ', time.time() - begin_ts)
    await out_.coro_put(None)


async def queue_func():
    out_ = ap.AioQueue()
    in_ = ap.AioQueue()
    p = ap.AioProcess(target=proc.start_queue_func, args=(out_, in_))
    p.start()
    begin_ts = time.time()
    for i in range(count):
        await out_.coro_put(data)
        res = await in_.coro_get()
    print('AioQueue: ', time.time() - begin_ts)
    await out_.coro_put(None)


async def pipe_func():
    main_, child_ = ap.AioPipe()
    p = ap.AioProcess(target=proc.start_pipe_func, args=(child_,))
    p.start()
    begin_ts = time.time()
    for i in range(count):
        await main_.coro_send(data)
        res = await main_.coro_recv()
    print('AioPipe: ', time.time() - begin_ts)
    await main_.coro_send(None)
    await p.coro_join()


server = None
async def handle_child(reader, writer):
    begin_ts = time.time()
    for i in range(count):
        writer.write(data)
        res = await reader.read(len(data))
    print('socket stream: ', time.time() - begin_ts)
    writer.close()


async def socket_func():
    global server
    addr = ('127.0.0.1', 8888)
    server = await asyncio.start_server(handle_child, *addr)
    p = ap.AioProcess(target=proc.start_socket_func, args=(addr,))
    p.start()
    async with server:
        await server.serve_forever()

async def subprocess_func():
    prog = await asyncio.create_subprocess_shell(
        'python proc.py',
        stdin=asyncio.subprocess.PIPE,
        stdout=asyncio.subprocess.PIPE)

    begin_ts = time.time()
    for i in range(count):
        prog.stdin.write(data)
        res = await prog.stdout.read(len(data))
    print('subprocess pipe stream: ', time.time() - begin_ts)
    prog.stdin.close()


async def main():
    await sync_simple_queue_func()
    await simple_queue_func()
    await queue_func()
    await pipe_func()
    await subprocess_func()
    await socket_func()


asyncio.run(main())

# proc.py

import asyncio
import sys

import aioprocessing as ap


async def sync_queue_func(in_, out_):
    while True:
        n = in_.get()
        if n is None:
            return
        out_.put(n)


async def queue_func(in_, out_):
    while True:
        n = await in_.coro_get()
        if n is None:
            return
        await out_.coro_put(n)

async def pipe_func(child):
    while True:
        n = await child.coro_recv()
        if n is None:
            return
        await child.coro_send(n)

data = b'*' * 100

async def socket_func(addr):

    reader, writer = await asyncio.open_connection(*addr)
    while True:
        n = await reader.read(len(data))
        if not n:
            break
        writer.write(n)


def start_sync_queue_func(in_, out_):
    asyncio.run(sync_queue_func(in_, out_))

def start_queue_func(in_, out_):
    asyncio.run(queue_func(in_, out_))


def start_pipe_func(child):
    asyncio.run(pipe_func(child))


def start_socket_func(addr):
    asyncio.run(socket_func(addr))


async def connect_stdin_stdout():
    loop = asyncio.get_event_loop()
    reader = asyncio.StreamReader()
    protocol = asyncio.StreamReaderProtocol(reader)
    dummy = asyncio.Protocol()
    await loop.connect_read_pipe(lambda: protocol, sys.stdin)  # sets read_transport
    w_transport, _ = await loop.connect_write_pipe(lambda: dummy, sys.stdout)
    writer = asyncio.StreamWriter(w_transport, protocol, reader, loop)
    return reader, writer


async def main():
    reader, writer = await connect_stdin_stdout()
    while True:
        res = await reader.read(len(data))
        if not res:
            break
        writer.write(res)


if __name__ == "__main__":
    asyncio.run(main())