如何使用 python 的 asyncio 模块正确创建和运行并发任务？

Question

我正在尝试使用 Python 3 的相对较新的asyncio模块正确理解和实现两个同时运行的Task对象。

简而言之，asyncio 似乎旨在通过事件循环处理异步进程和并发Task执行。 它提倡使用await （应用于异步函数）作为等待和使用结果的无回调方式，而不会阻塞事件循环。 （期货和回调仍然是一个可行的选择。）

它还提供了asyncio.Task() class，这是Future的专门子类，旨在包装协程。 最好使用asyncio.ensure_future()方法调用。 asyncio 任务的预期用途是允许独立运行的任务与同一事件循环中的其他任务“同时”运行。 我的理解是Tasks连接到事件循环，然后自动在await语句之间继续驱动协程。

我喜欢能够使用并发任务而不需要使用其中一个Executor类的想法，但我还没有找到关于实现的详细说明。

这就是我目前的做法：

import asyncio

print('running async test')

async def say_boo():
    i = 0
    while True:
        await asyncio.sleep(0)
        print('...boo {0}'.format(i))
        i += 1

async def say_baa():
    i = 0
    while True:
        await asyncio.sleep(0)
        print('...baa {0}'.format(i))
        i += 1

# wrap in Task object
# -> automatically attaches to event loop and executes
boo = asyncio.ensure_future(say_boo())
baa = asyncio.ensure_future(say_baa())

loop = asyncio.get_event_loop()
loop.run_forever()

在尝试同时运行两个循环任务的情况下，我注意到除非任务具有内部await表达式，否则它将卡在while循环中，从而有效地阻止其他任务运行（很像普通的while循环）。 但是，一旦任务必须（a）等待，它们似乎可以同时运行而没有问题。

因此， await语句似乎为事件循环提供了一个在任务之间来回切换的立足点，从而产生并发的效果。

带有内部await的示例 output ：

running async test
...boo 0
...baa 0
...boo 1
...baa 1
...boo 2
...baa 2

示例 output没有内部await ：

...boo 0
...boo 1
...boo 2
...boo 3
...boo 4

问题

此实现是否通过了asyncio中并发循环任务的“正确”示例？

唯一可行的方法是让Task提供阻塞点（ await表达式）以便事件循环处理多个任务，这是否正确？

Answer 1

是的，任何在您的事件循环中运行的协程都会阻止其他协程和任务运行，除非它

1. 使用yield from或await调用另一个协程（如果使用 Python 3.5+）。
2. 返回。

这是因为asyncio是单线程的； 事件循环运行的唯一方法是没有其他协程主动执行。 使用yield from / await暂时挂起协程，让事件循环有机会工作。

您的示例代码很好，但在许多情况下，您可能不希望长时间运行的代码不执行在事件循环内运行的异步 I/O。 在这些情况下，使用asyncio.loop.run_in_executor在后台线程或进程中运行代码通常更有意义。 如果您的任务受 CPU 限制， ProcessPoolExecutor将是更好的选择，如果您需要执行一些非asyncio友好的 I/O，则将使用ThreadPoolExecutor 。

例如，您的两个循环完全受 CPU 限制并且不共享任何状态，因此最好的性能来自使用ProcessPoolExecutor跨 CPU 并行运行每个循环：

import asyncio
from concurrent.futures import ProcessPoolExecutor

print('running async test')

def say_boo():
    i = 0
    while True:
        print('...boo {0}'.format(i))
        i += 1


def say_baa():
    i = 0
    while True:
        print('...baa {0}'.format(i))
        i += 1

if __name__ == "__main__":
    executor = ProcessPoolExecutor(2)
    loop = asyncio.get_event_loop()
    boo = loop.run_in_executor(executor, say_boo)
    baa = loop.run_in_executor(executor, say_baa)

    loop.run_forever()

Answer 2

您不一定需要yield from x的yield from x来控制事件循环。

在您的示例中，我认为正确的方法是执行yield None或等效的简单yield ，而不是yield from asyncio.sleep(0.001)的yield from asyncio.sleep(0.001) ：

import asyncio

@asyncio.coroutine
def say_boo():
  i = 0
  while True:
    yield None
    print("...boo {0}".format(i))
    i += 1

@asyncio.coroutine
def say_baa():
  i = 0
  while True:
    yield
    print("...baa {0}".format(i))
    i += 1

boo_task = asyncio.async(say_boo())
baa_task = asyncio.async(say_baa())

loop = asyncio.get_event_loop()
loop.run_forever()

协程只是普通的旧 Python 生成器。 在内部， asyncio事件循环会保存这些生成器的记录，并在永无止境的循环中对每个生成器调用gen.send() 。 无论何时yield ，对gen.send()的调用gen.send()完成并且循环可以继续。 （我正在简化它；查看https://hg.python.org/cpython/file/3.4/Lib/asyncio/tasks.py#l265以获得实际代码）

也就是说，如果您需要在不共享数据的情况下进行 CPU 密集型计算，我仍然会选择run_in_executor路线。

Answer 3

在 Python 3.10 中不推荐使用asyncio.ensure_future和asyncio.get_event_loop函数。

您可以通过asyncio.create_task同时运行两个协程say_boo和say_baa ：

async def main():
    boo = asyncio.create_task(say_boo())
    baa = asyncio.create_task(say_baa())
    await boo
    await baa

asyncio.run(main())

你也可以使用asyncio.gather

async def main():
    await asyncio.gather(say_boo(), say_baa())

asyncio.run(main())