Asynchronous programming and asyncio

Asynchronous programming is a model where tasks can be paused and resumed cooperatively, allowing one thread to handle many concurrent operations. In Python, async code uses the async and await keywords. It is well-suited for I/O-bound work like network servers, HTTP clients, and database access.

Asyncio is the standard library module for asynchronous programming with coroutines. It provides an event loop, primitives for synchronization, and APIs for networking, subprocesses, and queues. Asyncio is the foundation for many modern Python frameworks including FastAPI and aiohttp.

A coroutine is a function defined with async def that can be paused and resumed at await expressions. Calling a coroutine function does not run it; it returns a coroutine object that must be scheduled on an event loop. Coroutines are the building blocks of asyncio programs.

Await pauses the current coroutine until the awaited object completes, allowing the event loop to run other tasks in the meantime. You can await coroutines, tasks, and futures. Await can only be used inside an async function.

A coroutine is an awaitable object representing a paused computation. A Task wraps a coroutine and schedules it on the event loop, where it runs concurrently with other tasks. You create a Task with asyncio.create_task or asyncio.TaskGroup.

Gather runs multiple awaitables concurrently and waits for all of them to complete, returning their results as a list. It is the standard way to launch many tasks in parallel and collect their results. If any task raises an exception, gather either propagates it or returns it depending on the return_exceptions flag.

TaskGroup, added in Python 3.11, is a structured concurrency primitive. It is an async context manager that ensures all tasks created within it are awaited before exiting. If any task raises, others are cancelled and exceptions are collected into an exception group. TaskGroup is the recommended modern way to manage concurrent tasks.

Gather is older and more flexible but does not enforce structured concurrency: tasks can outlive the gather call. TaskGroup enforces structured concurrency: all tasks are bounded to the with block, and failures are handled cleanly via exception groups. New code should generally prefer TaskGroup.

Threading uses OS threads with preemptive scheduling and is limited by the GIL for CPU work. Asyncio uses cooperative scheduling on a single thread with explicit await points. Asyncio is lighter weight, scales to thousands of concurrent operations, and avoids many synchronization issues, but it requires async-aware libraries throughout the call stack.

A sync function executes from start to finish blocking the calling thread. An async function returns a coroutine that must be awaited. Async functions can pause at await points without blocking the thread. Mixing sync and async code carelessly can block the event loop and degrade performance.

Blocking the event loop means running synchronous code that takes significant time inside an async function, preventing other tasks from running. CPU-bound work, file I/O, and synchronous database calls all block the loop. The fix is to run blocking code in a thread pool with run_in_executor or use async-aware libraries. ---