Understanding Python's Event Loop Internals

The Event Loop is the heart of every asynchronous Python application. Whenever a FastAPI endpoint is defined using the async def keyword, it ultimately relies on the Event Loop for execution.

Most developers understand that asynchronous code somehow allows FastAPI to handle many requests efficiently. However, far fewer understand how the Event Loop actually achieves this.

This often becomes apparent during interviews. Questions such as:

- What is the Event Loop?
- What happens when a coroutine reaches an await statement?
- How does Python know when to resume a suspended coroutine?
- How can a single thread handle thousands of requests?
- Why does time.sleep() block FastAPI?

all require a solid understanding of Event Loop internals.

In this article, we will explore how the Event Loop works and understand why it is the foundation of FastAPI's concurrency model.

The Event Loop is a scheduler that continuously monitors and executes asynchronous tasks while efficiently handling I/O operations.

The Problem the Event Loop Solves

Modern backend systems spend most of their time waiting. A request may need to query a database, call another microservice, access Redis, read a file, or wait for a network response before it can continue processing.

Consider a database query:

def get_user():

    user = database.fetch_user()
    return user

While waiting for a database response, the thread does nothing useful and the CPU remains idle. However, the thread is still occupied and cannot be used for other work. This becomes a significant problem when thousands of requests are being processed concurrently.

Creating one thread per request becomes expensive because every thread consumes memory and operating system resources. The Event Loop solves this problem by allowing a single thread to switch between many waiting operations.

How the Event Loop Works?

Imagine three requests arriving simultaneously: Request A, Request B, and Request C. A traditional synchronous server might assign a separate thread to each request: Thread A for Request A, Thread B for Request B, and Thread C for Request C.

An asynchronous server uses a single event loop to manage multiple requests concurrently. Instead of assigning a separate thread to each request, the event loop coordinates the execution of Request A, Request B, and Request C.

The Event Loop rapidly switches between tasks whenever one of them becomes blocked waiting for I/O. This gives the illusion that all requests are progressing simultaneously.

The Lifecycle of a Coroutine

Consider the following coroutine:

async def fetch_user():
    user = await database.get_user()
    return user

When fetch_user() is called, the function does not execute immediately. Instead, Python creates a coroutine object.

At this stage, the coroutine object has been created, but it is not running and has not yet been scheduled by the event loop. No code inside the coroutine has executed yet.

The coroutine is simply a description of work that needs to be performed. Before any code inside the coroutine can execute, it must be scheduled by the Event Loop.

Let's see what happens next.

Suppose the Event Loop schedules the coroutine for execution. Event Loop → fetch_user(). Execution begins and the coroutine starts running.

The first executable statement is: user = await database.get_user(). At this point the coroutine needs data from the database before it can continue.

Since the database operation may take time, the coroutine cannot proceed immediately. The Event Loop suspends the coroutine and places it into a waiting state.

Control immediately returns to the Event Loop. The Event Loop is now free to execute other coroutines while the database query is running.

The Event Loop never waits. Whenever a coroutine pauses, the Event Loop looks for other work that can execute.

When the database eventually returns a response, the Event Loop is notified that the coroutine can continue. The Event Loop schedules the coroutine again and execution resumes exactly where it was suspended.

The coroutine completes and its result is returned to the caller.

What Happens During await?

This is one of the most important interview topics. When Python encounters await database.fetch_user() the following occurs:

1. The current coroutine pauses.
2. The Event Loop registers interest in the database operation.
3. Control returns to the Event Loop.
4. Other tasks execute.
5. The database eventually responds.
6. The Event Loop receives notification.
7. The suspended coroutine resumes.

This mechanism allows a single thread to remain productive while many I/O operations are pending.

How Does the Event Loop Know When to Resume a Coroutine?

The Event Loop continuously monitors operating system events. Examples include socket readiness, network responses, file operation completion, and timer expiration.

When an awaited operation completes, the operating system notifies the Event Loop. The Event Loop then marks the corresponding coroutine as ready for execution.

Internally, the Event Loop maintains a queue of tasks that are ready to execute. The event loop repeatedly takes a task from the queue, executes it, suspends it when necessary, and then moves on to the next task.

This cycle happens extremely quickly.

Why time.sleep() Breaks FastAPI?

Consider:

import time

@app.get("/users")
async def get_users():
    time.sleep(5)
    return {"status": "done"}

During those five seconds:

- The coroutine never yields control.
- The Event Loop cannot schedule other tasks.
- All requests become blocked.

Correct approach:

import asyncio

@app.get("/users")
async def get_users():
    await asyncio.sleep(5)
    return {"status": "done"}

Now the coroutine suspends and the Event Loop remains free to process other requests.

Important: Many candidates believe async functions automatically become non-blocking. A blocking call inside an async function still blocks the Event Loop.

How Uvicorn Uses the Event Loop

Uvicorn acts as the ASGI server. When a request arrives, it flows from the client to Uvicorn, Uvicorn submits the request to the Event Loop. The Event Loop schedules execution of the corresponding coroutine.

This architecture allows FastAPI to handle large numbers of concurrent requests efficiently.

Who Actually Performs the I/O Operations?

One of the most important concepts to understand is that the Event Loop does not perform I/O operations itself. It acts as a coordinator, while the actual I/O work is carried out by external systems and the operating system.

Consider the following example:

user = await database.get_user()

When this statement executes, the database query is sent to the database server. The Python process enters a waiting state, while the database server performs the actual query execution.

The Event Loop does not sit there waiting for the result. Instead, it registers interest in the database response and immediately moves on to other work.

The database server performs the query independently. Once the query completes, the database driver receives the response and the operating system notifies the Event Loop that data is available.

The Event Loop can then resume the suspended coroutine.

The Event Loop runs on a thread and executes Python code on that thread. However, it does not perform external I/O work itself. So the Event Loop is not merely scheduling. It is also executing Python code on its thread.

Who executes the database query?
- Not Python.
- Not the Event Loop.
- The database server does.

Meanwhile the Event Loop thread is free. The Event Loop keeps executing Python code for other requests.

The operating system tells the Event Loop: "The socket now has data available." The Event Loop then schedules the suspended coroutine again.

When the Event Loop Is Not Enough

Consider:

async def calculate():
    total = 0
    for i in range(500000000):
        total += i
    return total

This is CPU-bound work with no I/O operations involved. Since the coroutine never yields control, the event loop cannot improve performance. For CPU-intensive workloads, consider using multiprocessing, ProcessPoolExecutor, or distributed workers.

The Event Loop excels at managing waiting. It does not make CPU-heavy computations faster.

Interview Questions and Answers

What is the Event Loop? - The Event Loop is the scheduler responsible for executing coroutines, monitoring I/O operations, and resuming suspended tasks.

What happens during await? - The current coroutine pauses and control returns to the Event Loop.

How does the Event Loop know when to resume a coroutine? - The operating system notifies the Event Loop when the awaited operation completes.

Why does time.sleep() block FastAPI? - Because it blocks the Event Loop and prevents other coroutines from executing.

Can the Event Loop make CPU-bound code faster? - No. The Event Loop primarily improves I/O-bound workloads.

Why can FastAPI handle thousands of requests? - Because coroutines suspend while waiting for I/O, allowing the Event Loop to process other requests.

Conclusion

The Event Loop is the engine that powers asyncio and FastAPI. It continuously schedules coroutines, monitors I/O operations, suspends tasks that are waiting, and resumes them when work becomes available. Once you understand the Event Loop, the rest of the FastAPI execution model becomes much easier to reason about.