Async Programming in FastAPI

Introduction

One of the biggest reasons FastAPI is fast is its support for asynchronous programming (async/await).

In this blog, you’ll learn:

  • What async really means
  • Difference between sync and async
  • When to use each
  • How it improves performance

What is Asynchronous Programming?

Asynchronous programming allows your application to:

  • Handle multiple requests at the same time
  • Not block execution
  • Improve performance under heavy load

Think of it like:

  • Sync = one task at a time
  • Async = multiple tasks handled efficiently

What is Asynchronous Programming?

Asynchronous programming allows your application to:

  • Handle multiple requests at the same time
  • Not block execution
  • Improve performance under heavy load

Think of it like:

  • Sync = one task at a time
  • Async = multiple tasks handled efficiently

Sync vs Async Example

Synchronous Code

import time

def task():
    time.sleep(5)
    return "Done"

@app.get("/sync")
def sync_route():
    task()
    return {"message": "Completed"}

Blocks for 5 seconds

Why Async is Faster

  • While waiting (DB/API calls), FastAPI handles other requests
  • Better CPU utilization
  • High concurrency support

When to Use async

Use async when dealing with:

1. External APIs
2. Database calls
3. File I/O
4. Network operations

When NOT to Use async

Avoid async for:

1.CPU-heavy tasks (ML, image processing)
2.Simple operations

Use:

  • Multiprocessing
  • Task queues (Celery)

 Mixing Sync & Async

FastAPI supports both:

@app.get("/mix")
def sync_function():
    return {"message": "Sync works"}

@app.get("/mix-async")
async def async_function():
    return {"message": "Async works"}

Blocking vs Non-Blocking
Blocking (Bad in async)
import time

async def bad():
    time.sleep(5)  # blocks everything!
Non-Blocking
import asyncio

async def good():
    await asyncio.sleep(5)

Real-World Example
import httpx

@app.get("/external-api")
async def call_api():
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.example.com")
    return response.json()
Best Practices
1.Use async for I/O operations
2.Avoid blocking functions inside async
3.Use async libraries (httpx, async DB drivers)
4.Keep code clean and readable
Common Mistakes
1.Using time.sleep() in async
2.Overusing async everywhere
3.Mixing sync DB with async routes incorrectly
Key Takeaways
  • Async makes FastAPI highly performant

  • Use await for non-blocking operations

  • Not all code needs async

  • Choose wisely based on use case

Comments

Post a Comment

Popular posts from this blog

Database Integration in FastAPI (SQLAlchemy CRUD)

  Introduction So far, we’ve built APIs without storing data.But real-world applications need a database to: Store user data. Manage products. Persist application state. In this blog, we’ll connect FastAPI with a database using SQLAlchemy and perform CRUD operations . What is SQLAlchemy? SQLAlchemy is a powerful Python ORM (Object Relational Mapper) that allows you to: Interact with databases using Python code. Avoid writing raw SQL queries. Work with models instead of tables. Step 1: Install Dependencies pip install sqlalchemy (For SQLite, no extra driver needed) Project Structure Update app/ ├── main.py ├── database/ │ ├── connection.py ├── models/ │ ├── item.py ├── schemas/ │ ├── item.py ├── routes/ │ ├── item.py Step 2: Database Connection app/database/connection.py from sqlalchemy import create_engine from sqlalchemy . orm import sessionmaker , declarative_base DATABASE_URL = "sqlite:///./test.db" engine = create_engine ( DAT...
Read more

Middleware & CORS in FastAPI

  Introduction As your API grows, you may need to: Log requests Modify responses Handle cross-origin requests This is where Middleware and CORS (Cross-Origin Resource Sharing) come into play.They help control how requests and responses flow through your application. What is Middleware? Middleware is a function that runs: Before a request reaches your route After a response is returned Think of it as a pipeline layer between client and server. Request Flow with Middleware Client → Middleware → Route → Middleware → Response Creating Custom Middleware from fastapi import FastAPI , Request import time app = FastAPI () @ app . middleware ( "http" ) async def log_requests ( request : Request , call_next ): start_time = time . time() response = await call_next ( request ) process_time = time . time() - start_time print ( f"Request: { request . url} | Time: { process_time } " ) return response What This Middle...
Read more

Python Data Handling

Python Data Handling for Beginners In Python, data handling means storing, changing, and using data in different ways. In this post, you will learn: Lists Tuples Dictionaries Sets String Methods Type Conversion 1. Python Lists :Lists store many values in one variable.                fruits = ["apple", "banana", "mango"]                                                                       Method                          Use                                            append()          ...
Read more