Fast API Request Handling

In FastAPI, how route handlers (endpoints) behave in terms of parallelism and concurrency depends on whether they are defined using async def or def, and whether the work inside them is I/O-bound or CPU-bound.

Here are the four combinations of route handlers and how they affect parallel or concurrent handling of requests:

✅ 1. async def with async I/O-bound work (e.g., await asyncio.sleep, database calls)

@router.get("/async-io")
async def async_io_route():
    await asyncio.sleep(2)
    return {"status": "async io"}

• Handled concurrently
• Non-blocking — multiple such requests can be handled at the same time.
• Best performance for I/O tasks like DB queries, network calls, file access.

✅ 2. async def with CPU-bound work (e.g., heavy computation, no await)

@router.get("/async-cpu")
async def async_cpu_route():
    result = sum(i * i for i in range(10**7))
    return {"result": result}

• Not truly concurrent for CPU-bound work.
• Blocks the event loop — slows down other async endpoints.
• BAD practice — use a thread pool for CPU-bound tasks instead.

✅ 3. def with CPU-bound work

@router.get("/sync-cpu")
def sync_cpu_route():
    result = sum(i * i for i in range(10**7))
    return {"result": result}

• Parallel execution via thread pool executor (Starlette/FastAPI handles this).
• Slower than async I/O but doesn't block the event loop.
• Suitable for CPU-bound work when properly limited.

✅ 4. def with I/O-bound work (e.g., time.sleep)

@router.get("/sync-io")
def sync_io_route():
    time.sleep(2)
    return {"status": "sync io"}

• Blocks thread and wastes resources.
• Not concurrent nor parallel in a performant way.
• Worst option — avoid using blocking I/O in sync routes.

Summary Table

✅ Best Practices

• Use async def + await for I/O-bound operations.
• Offload CPU-heavy operations to a thread/process pool (e.g., run_in_executor()).
• Avoid blocking operations like time.sleep() in FastAPI routes.

Here’s a clear and concise table showing different FastAPI route types, the kind of operation they perform, and whether the request handling is parallel or concurrent:

🧩 FastAPI Route Behavior Comparison

✅ Legend

• Concurrent: Multiple tasks share the same thread (async I/O).
• Parallel: Tasks run in separate threads or processes simultaneously.
• Blocking: One task prevents others from proceeding.