asyncio 事件循环是否只运行任务？

Question

I'm in the early stages of learning about the asyncio library. I'm starting off with coroutines and tasks, and reading through the hello world examples in the docs .

Based on the section about coroutines, it seems there are two main ways of running a coroutine object:

• Using await on a coroutine
• Running coroutines as asyncio Tasks

According to the Task docs:

Tasks are used to run coroutines in event loops.

To be clear, does this imply the event loop doesn't run coroutine objects unless they are wrapped into a task? In this situation, are these coroutine objects just run synchronously without any interaction with the event loop?

Answer 1

To be clear, does this [that tasks are used to run coroutines] imply the event loop doesn't run coroutine objects unless they are wrapped into a task?

It means that tasks are the entry point into the coroutine world. Each coroutine can be traced to being awaited by an outer coroutine, all the way to a coroutine that is driven by a task.

Take this example code:

async def inner():
    await asyncio.sleep(1)

async def outer():
    await inner()
    await inner()

async def main():
    await outer()

asyncio.run(main())

asyncio.run implicitly creates one task to drive the main coroutine to completion. The task only "sees" the coroutine object created by invoking main() and is unconcerned with the coroutine main awaits. From the point of view of the task, main will suspend twice, once for each sleep . Prior to suspending, the sleep coroutine will arrange with the event loop for the task to be resumed.

In this situation, are these coroutine objects just run synchronously without any interaction with the event loop?

All coroutines must interact with the event loop because they must be able to suspend . If they are awaited by another coroutine, they cause the awaiting coroutine to suspend. This propagates up to the top-level coroutine which is run by a task, and that causes the task to suspend.