asyncio – Sesame Disk Group

If you’re building high-throughput Python services, async/await can cut I/O wait times from minutes to seconds. But effective async code requires more than sprinkling async and await everywhere. You need the right patterns, a solid grasp of Python’s async fundamentals, and careful testing. Here’s how to structure reliable async Python in production—without falling into the common traps that undermine concurrency and maintainability.

Key Takeaways:

Master the async/await model: understand coroutines, the event loop, and awaitable types

Apply proven concurrency patterns to maximize efficiency and avoid bottlenecks

Test async code robustly using pytest-asyncio auto mode and modern practices

Recognize and avoid the async patterns that lead to subtle bugs or performance issues

Know when async is the wrong tool and what alternatives to consider

Async Fundamentals: Coroutines, Event Loop, and Awaitables

Python’s asyncio framework is built on three critical concepts: coroutines, the event loop, and awaitable objects. Mastering these is essential for writing production-ready async code.

Defining and Running Coroutines

import asyncio

async def fetch_user(user_id):
    # Simulating an API call
    await asyncio.sleep(0.2)
    return {"id": user_id, "name": f"User {user_id}"}

# This creates a coroutine object but doesn't execute the function
coro = fetch_user(1)
# You must await it to actually run
# result = await fetch_user(1)  # Only valid inside another coroutine

A function defined with async def returns a coroutine object when called—it doesn’t run immediately. You must await it from inside another coroutine or schedule it on the event loop. (source)

The Event Loop: Orchestrating Concurrency

async def main():
    user = await fetch_user(42)
    print(user)

asyncio.run(main())

The event loop drives asynchronous execution. When a coroutine hits await (such as waiting on network I/O), the event loop switches to another runnable coroutine. Use asyncio.run() to create and manage the event loop in modern Python.

What Can You Await?

Coroutines: Functions defined with async def
Tasks: Coroutines scheduled with asyncio.create_task()
Futures: Low-level primitives, typically handled by libraries

You can await any object that is awaitable. Attempting to await a non-awaitable object will raise a TypeError.

Async Context Managers

import asyncio

class AsyncContextManager:
    async def __aenter__(self):
        print('Acquiring resource')
        return self

    async def __aexit__(self, exc_type, exc_value, traceback):
        print('Releasing resource')

async def main():
    async with AsyncContextManager() as resource:
        print('Using resource')

asyncio.run(main())
# Output:
# Acquiring resource
# Using resource
# Releasing resource

Async context managers enable safe acquisition and release of resources in async code, such as database connections or network handles.

Production Patterns: Structuring and Scaling Async Code

Async code only delivers performance gains if you structure it for proper concurrency. The main patterns are parallel execution with asyncio.gather() and concurrency limiting with asyncio.Semaphore.

Running Tasks in Parallel: asyncio.gather

import asyncio

async def fetch_user(user_id):
    await asyncio.sleep(0.2)
    return {"id": user_id, "name": f"User {user_id}"}

async def fetch_all_users(user_ids):
    coros = [fetch_user(uid) for uid in user_ids]
    results = await asyncio.gather(*coros)
    return results

user_ids = range(1, 6)
users = asyncio.run(fetch_all_users(user_ids))
print(users)
# Output: [{'id': 1, 'name': 'User 1'}, {'id': 2, 'name': 'User 2'}, {'id': 3, 'name': 'User 3'}, {'id': 4, 'name': 'User 4'}, {'id': 5, 'name': 'User 5'}]

asyncio.gather() fires off all coroutines and waits for them to complete in parallel. This is how you collapse multi-minute API workloads into a few seconds.

Limiting Concurrency with asyncio.Semaphore

import asyncio

async def fetch_user(user_id, sem):
    async with sem:
        await asyncio.sleep(0.2)
        return {"id": user_id, "name": f"User {user_id}"}

async def fetch_all_users(user_ids, max_concurrency=3):
    sem = asyncio.Semaphore(max_concurrency)
    coros = [fetch_user(uid, sem) for uid in user_ids]
    results = await asyncio.gather(*coros)
    return results

user_ids = range(1, 10)
users = asyncio.run(fetch_all_users(user_ids))
print(users)
# Only 3 fetches run concurrently at any time

Use asyncio.Semaphore to control the number of concurrent tasks—critical when calling external APIs or services with rate limits. (source)

When Async is the Wrong Tool

CPU-bound work: Use concurrent.futures.ProcessPoolExecutor or multiprocessing instead
Synchronous-only libraries: If a library doesn’t support async, you’ll block the event loop
Simple scripts: Async adds complexity that may not pay off for trivial tasks

As emphasized in the research, async is a powerful tool, but the wrong fit for CPU-heavy or blocking code. (source)

Exception Handling in Async Code

import asyncio

async def risky_operation():
    raise ValueError('An error occurred!')

async def main():
    try:
        await risky_operation()
    except ValueError as e:
        print(f'Caught an exception: {e}')

asyncio.run(main())
# Output: Caught an exception: An error occurred!

Always handle exceptions inside your coroutines to avoid silent failures or unhandled errors that can crash your event loop.

Testing Async Code: pytest-asyncio and Best Practices

Testing async code requires a runner that understands coroutines and event loops. In 2026, pytest-asyncio is considered the standard for async Python tests. (source)

Installing pytest-asyncio

pip install pytest pytest-asyncio

Install both pytest and pytest-asyncio to get started.

Auto Mode: Async Tests Without Decorators

# content of test_async.py
import asyncio

async def fetch_user(user_id):
    await asyncio.sleep(0.1)
    return {"id": user_id}

async def test_fetch_user():
    result = await fetch_user(99)
    assert result["id"] == 99

With auto mode in pytest-asyncio, you no longer need @pytest.mark.asyncio—every test is treated as a coroutine. (source)

pytest Fixtures and Event Loop Scope

pytest-asyncio integrates with standard pytest fixtures, but be mindful of scope and event loop lifetime. Improper scoping can lead to fixture or resource cleanup issues.

# Example for illustration—refer to official pytest-asyncio docs for production usage
import pytest

@pytest.fixture
def some_resource():
    return "resource"

async def test_async_with_fixture(some_resource):
    assert some_resource == "resource"

Always verify fixture/event loop integration with the official documentation.

Limitations and Alternatives: pytest-asyncio and Competing Tools

pytest-asyncio is widely adopted, but it’s not perfect. Here’s how it compares to notable alternatives for testing async code in Python.

Tool	Strengths	Limitations / Pain Points	Notable Alternatives
pytest-asyncio	Seamless integration with pytest Auto mode for async coroutines Widely used and well-supported	Slower when running large-scale concurrent tests Event loop/fixture scoping issues in advanced setups Does not natively support true parallel async test execution	pytest-trio (Trio framework) pytest-asyncio-concurrent (for improved concurrency) unittest + asyncio (less ergonomic)

If you need to run hundreds of async tests in parallel, consider pytest-asyncio-concurrent or pytest-trio (for trio-based async code). For legacy or synchronous test suites, unittest can work, but lacks modern async ergonomics.

Pro Tips and Common Pitfalls in Async Python

Never mix sync blocking code inside async coroutines: Calling blocking functions (like requests.get()) inside async def will hang your event loop and kill concurrency.
Avoid “fire-and-forget” tasks unless managed: If you use asyncio.create_task() and don’t track the task, you risk resource leaks and missed exceptions.
Watch for race conditions: Async code is concurrent—protect shared resources with locks or queues if needed.
Understand cancellation: Cancelled tasks can leave resources inconsistent; always use try/finally for cleanup.
Use asyncio.run() to manage the event loop: Don’t rely on global event loop APIs, especially in tests or scripts.

Most of these pitfalls are covered in detail in Mastering Python Async Patterns and Modern Python Best Practices: The 2026 Definitive Guide. For related real-world impacts, see How Agentic AI is Transforming Engineering Workflows in 2026 and Generative AI in Software Engineering: A Year in Retrospective.

Conclusion and Next Steps

Async/await is a powerful tool for scaling Python’s I/O-bound workloads—but only when you use the right patterns, test rigorously, and avoid subtle traps. Start by mastering the coroutine/event loop model, structure your code for concurrency, and use pytest-asyncio’s auto mode for streamlined testing. For deeper dives, consult the official asyncio documentation and the comprehensive research linked above.

If you’re interested in how async and AI-driven workflows are changing engineering, check out How Agentic AI is Transforming Engineering Workflows and Generative AI in Software Engineering: A Year in Retrospective.

Sources and References

This article was researched using the following sources:

References

Mastering Python Async Patterns: A Complete Guide to asyncio in 2026 - DEV Community

Critical Analysis

Get Started — pytest documentation