How does the asyncio event loop schedule coroutines?

Q: How does the asyncio event loop schedule coroutines?

**Target Audience:** Developers comfortable with `async`/`await` who want to explain, precisely, how asyncio orders and resumes work. **Difficulty:** Hard **Python version:** Example 1 (a model scheduler, no asyncio) runs in the page on Pyodide 0.25.1 (CPython 3.11.3) and was checked on CPython 3.11. Example 2 uses the real asyncio loop and `asyncio.eager_task_factory`, so it was run on CPython 3.12 (3.13 printed the same). Source references are to CPython 3.12 `Lib/asyncio/base_events.py` and `tasks.py`. > **How to read this doc:** Every idea comes in plain language first. Words an interviewer expects you to use are tagged `📌 Interview term:` and defined on the spot; all of them are repeated in the Quick Glossary at the end. Every output shown was printed by a real run. ## 1. Why This Even Matters — A Story First An air-traffic controller works alone in the tower. She keeps three things: 1. **A list of planes cleared to move right now**, handled strictly in order — first in, firs

The problem

Question presented to candidate: "Inside asyncio there is one thread and possibly thousands of coroutines. How does the event loop decide what runs next? Walk me through what happens between create_task(), an await on a socket or a sleep, and the coroutine being resumed."

What a strong answer should cover:

The loop holds a ready queue of callbacks (a FIFO collections.deque), a heap of timers for call_later/call_at, and a selector (epoll, kqueue, ...) for I/O. Each iteration (_run_once) waits on the selector with a timeout based on the earliest timer, moves due timers and I/O callbacks to the ready queue, then runs exactly the callbacks that were ready at that moment.
The loop only runs callbacks; a Task turns a coroutine into callbacks: each Task.__step calls coro.send(None) until the coroutine yields a Future, then registers a done-callback that schedules the next step.
Futures connect the two worlds: when I/O completes or a timer fires, set_result schedules the waiting Tasks with call_soon.
Ordering consequences: create_task does not start the coroutine until the current task suspends; call_soon is FIFO; await asyncio.sleep(0) yields one turn; a coroutine that never awaits starves everything (cooperative scheduling).
3.12 added asyncio.eager_task_factory, which runs a new task synchronously up to its first suspension; debug mode reports slow callbacks.

Code / implementation expected: Optional — a tiny scheduler model, or a script that prints the order in which tasks and callbacks run.

asyncio
event-loop

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Developers comfortable with async/await who want to explain, precisely, how asyncio orders and resumes work. Difficulty: Hard Python version: Example 1 (a model scheduler, no asyncio) runs in the page on Pyodide 0.25.1 (CPython 3.11.3) and was checked on CPython 3.11. Example 2 uses the real asyncio loop and asyncio.eager_task_factory, so it was run on CPython 3.12 (3.13 printed the same). Source references are to CPython 3.12 Lib/asyncio/base_events.py and tasks.py.

How to read this doc: Every idea comes in plain language first. Words an interviewer expects you to use are tagged 📌 Interview term: and defined on the spot; all of them are repeated in the Quick Glossary at the end. Every output shown was printed by a real run.

1. Why This Even Matters — A Story First

An air-traffic controller works alone in the tower. She keeps three th

The solution is hidden so you can try first

12 min read · 13 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

PythonA model scheduler: ready queue, timer heap, Futures and Tasks

Practice

PythonReal asyncio ordering: call_soon, create_task, eager tasks, fairness

# The real asyncio loop: what runs in which order. Runs on CPython 3.12+
# (asyncio.eager_task_factory is new in 3.12; asyncio.run needs no page loop).
import asyncio

order = []


async def child(name):
    order.append(f"{name} step 1")
    await asyncio.sleep(0)                 # yield: go to the back of the ready queue
    order.append(f"{name} step 2")


async def lazy_tasks():
    loop = asyncio.get_running_loop()
    loop.call_soon(order.append, "call_soon #1")
    loop.call_later(0, order.append, "call_later(0)")
    t1 = asyncio.create_task(child("t1"))  # queued; does NOT run yet
    t2 = asyncio.create_task(child("t2"))
    loop.call_soon(order.append, "call_soon #2")
    order.append("main still running: create_task did not switch")
    await asyncio.sleep(0)                 # main yields for the first time
    order.append("main resumed")
    await asyncio.gather(t1, t2)
    order.append("main done")


async def eager_tasks():
    asyncio.get_running_loop().set_task_factory(asyncio.eager_task_factory)
    t1 = asyncio.create_task(child("e1"))  # runs NOW, up to its first await
    order.append("main after creating e1")
    await t1
    async def instant():
        return "x"                         # never awaits anything
    quick = asyncio.create_task(instant())
    slow = asyncio.create_task(asyncio.sleep(0))
    order.append(f"instant done before any yield? {quick.done()}")
    order.append(f"sleep(0) done before any yield? {slow.done()}")
    await slow


async def ticker():
    for i in range(3):
        order.append(f"  tick {i}")
        await asyncio.sleep(0)


async def greedy():
    for i in range(3):
        order.append(f"greedy {i}")        # no await inside: never yields


async def cooperative():
    for i in range(3):
        order.append(f"coop {i}")
        await asyncio.sleep(0)             # a checkpoint: let others run


async def fairness():
    await asyncio.gather(ticker(), greedy())
    order.append("----")
    await asyncio.gather(ticker(), cooperative())


for demo in (lazy_tasks, eager_tasks, fairness):
    order.clear()
    asyncio.run(demo())
    print(f"--- {demo.__name__}")
    for i, line in enumerate(order, 1):
        print(f"{i:2}. {line}")

Discussion

Other approaches, follow-ups and how it went in real interviews.

Sign in to join the discussion.

No comments yet. Share how you would answer it.

The solution is hidden so you can try first

Keep your momentum going.