Concurrent task execution in FastAPI - Step-by-Step Execution

Concept Flow - Concurrent task execution

Start API Request

↓

Define async tasks

↓

Run tasks concurrently

↓

Wait for all tasks to finish

↓

Collect results

↓

Send response

This flow shows how FastAPI handles multiple async tasks at the same time, waits for all to finish, then sends back the combined results.

Execution Sample

FastAPI

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get('/tasks')
async def run_tasks():
    async def task(id):
        await asyncio.sleep(1)
        return f'Task {id} done'
    results = await asyncio.gather(task(1), task(2), task(3))
    return {'results': results}

This FastAPI endpoint runs three async tasks concurrently, waits for all to complete, then returns their results.

Execution Table

Step	Action	Task 1 State	Task 2 State	Task 3 State	Results Collected
1	Start run_tasks endpoint	Not started	Not started	Not started	[]
2	Call asyncio.gather with 3 tasks	Started (sleeping)	Started (sleeping)	Started (sleeping)	[]
3	After 1 second, Task 1 completes	Completed	Sleeping	Sleeping	[]
4	After 1 second, Task 2 completes	Completed	Completed	Sleeping	[]
5	After 1 second, Task 3 completes	Completed	Completed	Completed	[]
6	Gather returns all results	Completed	Completed	Completed	['Task 1 done', 'Task 2 done', 'Task 3 done']
7	Return response with results	Completed	Completed	Completed	['Task 1 done', 'Task 2 done', 'Task 3 done']

💡 All tasks complete after 1 second, gather returns results, endpoint returns response.

Variable Tracker

Variable	Start	After Step 2	After Step 6	Final
results	undefined	undefined	['Task 1 done', 'Task 2 done', 'Task 3 done']	['Task 1 done', 'Task 2 done', 'Task 3 done']
Task 1 State	Not started	Started (sleeping)	Completed	Completed
Task 2 State	Not started	Started (sleeping)	Completed	Completed
Task 3 State	Not started	Started (sleeping)	Completed	Completed

Key Moments - 3 Insights

Why do all tasks complete after the same 1 second wait instead of 3 seconds total?

Because asyncio.gather runs tasks concurrently, all tasks sleep at the same time, so total wait is just 1 second, not the sum of each.

What happens if one task raises an error during asyncio.gather?

asyncio.gather will raise that error immediately and stop waiting for other tasks, so the endpoint will return an error response.

Why do we use 'await' before asyncio.gather?

Because asyncio.gather returns a coroutine, 'await' pauses the function until all tasks finish and results are ready.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of Task 2 at Step 4?

A Sleeping

B Not started

C Completed

D Error

💡 Hint

Check the 'Task 2 State' column at Step 4 in the execution_table.

At which step does the 'results' variable get its final list of task outputs?

A Step 6

B Step 4

C Step 2

D Step 7

💡 Hint

Look at the 'Results Collected' column in execution_table rows.

If we remove 'await' before asyncio.gather, what changes in variable_tracker?

A 'results' immediately has all task outputs

B 'results' becomes a coroutine, not a list

C Tasks run sequentially instead of concurrently

D No change, code runs the same

💡 Hint

Recall that without 'await', asyncio.gather returns a coroutine object, not results.

Concept Snapshot

FastAPI concurrent tasks use async def and asyncio.gather.
Multiple async tasks run at the same time.
Use 'await' to pause until all finish.
Results come back as a list in order.
This speeds up waiting for many tasks.

Full Transcript

This example shows how FastAPI runs multiple asynchronous tasks concurrently using asyncio.gather. When the endpoint is called, it starts three tasks that each wait for one second. Because they run at the same time, the total wait is just one second, not three. After all tasks finish, their results are collected into a list and returned as the response. The key is using 'await' with asyncio.gather to pause until all tasks complete. If one task fails, the whole gather call raises an error. This method helps handle many tasks efficiently without blocking the server.