What is Async Programming?

Definition

Async programming is a paradigm that allows code to perform non-blocking I/O operations. Instead of waiting idle while a database query or HTTP request completes, the program can switch to other tasks and resume when the result is ready.

Python introduced native async support with asyncio in Python 3.4 and the async/await syntax in Python 3.5. This enables writing concurrent code that looks synchronous, making it readable and maintainable.

How Async Works in Python

Python's async model is based on an event loop that manages coroutines:

1. Mark a function as async def to make it a coroutine.
2. Use await before any I/O operation to yield control back to the event loop.
3. While one coroutine waits for I/O, the event loop runs other ready coroutines.
4. When the I/O completes, the original coroutine resumes.

This is cooperative multitasking - coroutines voluntarily yield control at await points. It's single-threaded, so there are no race conditions or locks needed.

When to Use Async

Async is ideal for I/O-bound workloads:

• Database queries (asyncpg, motor, aioredis)
• HTTP API calls (httpx, aiohttp)
• File I/O operations
• WebSocket connections
• Message queue consumers

Async is not helpful for CPU-bound work like image processing or mathematical computation. For those, use multiprocessing or threading.

Code Example

import asyncio
import httpx

async def fetch_url(client: httpx.AsyncClient, url: str) -> str:
    response = await client.get(url)
    return response.text

async def main():
    urls = [
        "https://api.example.com/users",
        "https://api.example.com/posts",
        "https://api.example.com/comments",
    ]

    async with httpx.AsyncClient() as client:
        # Fetch all URLs concurrently - not sequentially!
        results = await asyncio.gather(
            *[fetch_url(client, url) for url in urls]
        )
        # All 3 requests completed in the time of the slowest one
        print(f"Fetched {len(results)} responses")

asyncio.run(main())

Frequently Asked Questions

Is async Python faster than sync?

For I/O-bound tasks, yes - significantly. Async can handle thousands of concurrent I/O operations with a single thread. For CPU-bound tasks, async provides no benefit. The speedup comes from not wasting time waiting on I/O, not from parallel computation.

Can I mix sync and async code?

Yes, but carefully. You can run sync code in async context using asyncio.to_thread() or loop.run_in_executor(). Going the other way (running async from sync) requires asyncio.run() or creating an event loop. FastAPI handles this automatically for sync route handlers.