Concurrent task execution in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI endpoint using async tasks?

Consider this FastAPI endpoint that runs two async tasks concurrently and returns their results.

What will the response JSON be when calling this endpoint?

FastAPI

from fastapi import FastAPI
import asyncio

app = FastAPI()

async def task1():
    await asyncio.sleep(1)
    return "task1 done"

async def task2():
    await asyncio.sleep(1)
    return "task2 done"

@app.get("/run-tasks")
async def run_tasks():
    results = await asyncio.gather(task1(), task2())
    return {"results": results}

A {"results": ["task1 done"]}

B {"results": ["task2 done", "task1 done"]}

C {"results": ["task1 done", "task2 done"]}

D {"results": []}

💡 Hint

Think about how asyncio.gather collects results in order of the tasks passed.

asyncio.gather runs tasks concurrently but returns results in the order of the input tasks. So task1's result comes first, then task2's.

📝 Syntax

intermediate

Which option correctly runs multiple tasks concurrently in FastAPI?

You want to run three async functions concurrently inside a FastAPI endpoint and wait for all to finish. Which code snippet is correct?

A results = [await func1(), await func2(), await func3()]

B results = await asyncio.gather(func1(), func2(), func3())

C results = asyncio.gather(func1(), func2(), func3())

D results = await asyncio.wait({func1(), func2(), func3()})

💡 Hint

Remember that asyncio.gather returns a coroutine that must be awaited.

Option B correctly awaits asyncio.gather which runs all tasks concurrently and returns their results as a list. Option B runs tasks sequentially. Option B misses await so results is a coroutine object. Option B is incorrect usage of asyncio.wait which expects a set of tasks.

🔧 Debug

advanced

Why does this FastAPI endpoint hang indefinitely?

This FastAPI endpoint is supposed to run two async tasks concurrently and return their results. But it never responds. Why?

Code:
from fastapi import FastAPI
import asyncio

app = FastAPI()

async def task1():
await asyncio.sleep(1)
return "done1"

async def task2():
await asyncio.sleep(1)
return "done2"

@app.get("/hang")
def hang():
results = asyncio.gather(task1(), task2())
return {"results": results}

FastAPI

from fastapi import FastAPI
import asyncio

app = FastAPI()

async def task1():
    await asyncio.sleep(1)
    return "done1"

async def task2():
    await asyncio.sleep(1)
    return "done2"

@app.get("/hang")
def hang():
    results = asyncio.gather(task1(), task2())
    return {"results": results}

A The tasks are blocking the event loop causing a deadlock.

B The endpoint is missing a return statement.

C asyncio.gather is used incorrectly with synchronous functions.

D The endpoint is not async and does not await asyncio.gather, so it returns a coroutine object instead of running it.

💡 Hint

Check if the endpoint function is async and if await is used properly.

The endpoint function is synchronous (def) but calls asyncio.gather without await. This returns a coroutine object instead of running it, so the server never completes the response.

❓ state_output

advanced

What is the output order of concurrent tasks with different sleep times?

Given this FastAPI endpoint, what will be the order of results in the response?

Code:
from fastapi import FastAPI
import asyncio

app = FastAPI()

async def fast_task():
await asyncio.sleep(0.1)
return "fast"

async def slow_task():
await asyncio.sleep(0.5)
return "slow"

@app.get("/order")
async def order():
results = await asyncio.gather(slow_task(), fast_task())
return {"results": results}

FastAPI

from fastapi import FastAPI
import asyncio

app = FastAPI()

async def fast_task():
    await asyncio.sleep(0.1)
    return "fast"

async def slow_task():
    await asyncio.sleep(0.5)
    return "slow"

@app.get("/order")
async def order():
    results = await asyncio.gather(slow_task(), fast_task())
    return {"results": results}

A {"results": ["slow", "fast"]}

B {"results": ["fast", "slow"]}

C {"results": ["slow"]}

D {"results": ["fast"]}

💡 Hint

asyncio.gather returns results in the order of the input tasks, not completion order.

Even though fast_task finishes first, asyncio.gather returns results in the order tasks were passed. slow_task is first, so its result is first.

🧠 Conceptual

expert

Which statement about FastAPI concurrency with asyncio is TRUE?

Select the correct statement about how FastAPI handles concurrent async tasks using asyncio.

A FastAPI automatically runs multiple requests in parallel using asyncio event loop without blocking synchronous code.

B Using async def endpoints with blocking code inside them improves concurrency performance.

C FastAPI requires all endpoint functions to be synchronous to handle concurrency properly.

D asyncio.gather runs tasks sequentially, so concurrency is not achieved.

💡 Hint

Think about how async endpoints and the event loop work in FastAPI.

FastAPI uses the asyncio event loop to run async endpoints concurrently, allowing multiple requests to be processed without blocking. Synchronous blocking code inside async endpoints can block the event loop and reduce concurrency.

Practice

1. What is the main benefit of using asyncio.create_task() in FastAPI?

easy

A. It stops all tasks from running until manually restarted.

B. It makes the code run slower by adding delays.

C. It converts synchronous code into synchronous code.

D. It allows running multiple tasks at the same time without waiting for each to finish.

Solution

1. Step 1: Understand asyncio.create_task() purpose

   This function schedules a coroutine to run concurrently as a separate task without blocking the main program.

2. Step 2: Identify the benefit in FastAPI context

   Using it lets FastAPI handle multiple operations at once, improving responsiveness and efficiency.

3. Final Answer:

   It allows running multiple tasks at the same time without waiting for each to finish. -> Option D

4. Quick Check:

   Concurrent task execution = run tasks simultaneously [OK]

Hint: Remember: create_task starts tasks without waiting [OK]

Common Mistakes:

• Thinking create_task slows code down
• Confusing async with sync code
• Believing tasks stop until restarted

2. Which of the following is the correct way to run two async functions concurrently and wait for both to finish in FastAPI?

easy

A. func1(); func2()

B. await asyncio.create_task(func1()); await asyncio.create_task(func2())

C. await asyncio.gather(func1(), func2())

D. asyncio.run(func1(), func2())

Solution

1. Step 1: Understand how to run and wait for multiple async tasks

   asyncio.gather() runs multiple coroutines concurrently and waits for all to complete.

2. Step 2: Check each option's correctness

   await asyncio.gather(func1(), func2()) correctly uses await asyncio.gather(func1(), func2()). await asyncio.create_task(func1()); await asyncio.create_task(func2()) starts tasks but awaits them separately, not concurrently. func1(); func2() runs functions synchronously. asyncio.run(func1(), func2()) is invalid syntax.

3. Final Answer:

   await asyncio.gather(func1(), func2()) -> Option C

4. Quick Check:

   Use gather to run and wait multiple tasks [OK]

Hint: Use gather to wait all tasks together [OK]

Common Mistakes:

• Awaiting tasks separately losing concurrency
• Calling async functions without await
• Using asyncio.run inside async code

3. Given this FastAPI async endpoint code, what will be the output?

import asyncio
from fastapi import FastAPI
app = FastAPI()

async def task1():
    await asyncio.sleep(1)
    return "Task 1 done"

async def task2():
    await asyncio.sleep(2)
    return "Task 2 done"

@app.get("/run")
async def run_tasks():
    results = await asyncio.gather(task1(), task2())
    return {"results": results}

medium

A. {"results": ["Task 1 done", "Task 2 done"]}

B. {"results": ["Task 2 done", "Task 1 done"]}

C. {"results": ["Task 1 done"]}

D. TimeoutError

Solution

1. Step 1: Analyze the async tasks and their sleep durations

   task1 sleeps 1 second, task2 sleeps 2 seconds. Both run concurrently with gather.

2. Step 2: Understand gather result order

   asyncio.gather returns results in the order of the input tasks, regardless of completion time.

3. Final Answer:

   {"results": ["Task 1 done", "Task 2 done"]} -> Option A

4. Quick Check:

   Gather preserves input order in results [OK]

Hint: Gather returns results in input order, not finish order [OK]

Common Mistakes:

• Assuming results order matches finish order
• Expecting partial results if one task is slower
• Confusing gather with wait

4. What is wrong with this FastAPI code snippet for running tasks concurrently?

import asyncio
from fastapi import FastAPI
app = FastAPI()

async def task():
    await asyncio.sleep(1)
    return "Done"

@app.get("/test")
async def test():
    task1 = asyncio.create_task(task())
    task2 = asyncio.create_task(task())
    return {"result": task1.result() + task2.result()}

medium

A. Calling task1.result() before task completion causes an error.

B. Using create_task is not allowed in FastAPI endpoints.

C. The tasks should not be async functions.

D. The endpoint should not be async.

Solution

1. Step 1: Identify how task results are accessed

   Calling task1.result() immediately after creating the task tries to get the result before the task finishes, causing an error.

2. Step 2: Understand correct way to wait for task completion

   You must await the task or use await asyncio.gather(task1, task2) before accessing results.

3. Final Answer:

   Calling task1.result() before task completion causes an error. -> Option A

4. Quick Check:

   Access task result only after await [OK]

Hint: Always await tasks before accessing results [OK]

Common Mistakes:

• Accessing .result() too early
• Thinking create_task is forbidden
• Making endpoint synchronous

5. You want to run three independent async tasks in a FastAPI endpoint and return their results as soon as all finish. Which approach correctly handles errors in any task without stopping others and returns all results or error messages?

hard

A. Use asyncio.create_task() for each task but do not await them before returning.

B. Use asyncio.gather(task1(), task2(), task3(), return_exceptions=True) and process results for exceptions.

C. Use await task1(); await task2(); await task3() sequentially and catch exceptions globally.

D. Run tasks synchronously in a loop and catch exceptions inside each.

Solution

1. Step 1: Understand error handling in concurrent tasks

   Using asyncio.gather() with return_exceptions=True lets all tasks run concurrently and collects exceptions as results without stopping others.

2. Step 2: Compare options for correct concurrency and error handling

   Use asyncio.gather(task1(), task2(), task3(), return_exceptions=True) and process results for exceptions. correctly runs all tasks concurrently and handles errors individually. Use await task1(); await task2(); await task3() sequentially and catch exceptions globally. runs tasks sequentially, losing concurrency. Use asyncio.create_task() for each task but do not await them before returning. does not await tasks, so results are unavailable. Run tasks synchronously in a loop and catch exceptions inside each. runs synchronously, blocking concurrency.

3. Final Answer:

   Use asyncio.gather(task1(), task2(), task3(), return_exceptions=True) and process results for exceptions. -> Option B

4. Quick Check:

   Gather with return_exceptions handles errors concurrently [OK]

Hint: Use gather with return_exceptions=True for safe concurrency [OK]

Common Mistakes:

• Awaiting tasks sequentially losing concurrency
• Not awaiting tasks before returning
• Ignoring exceptions stopping all tasks