Concurrent Python Coroutines with `async`/`await` and `asyncio.gather`

From Functions to Coroutines

In standard Python, a function call executes code immediately. In the asyncio world, things are a bit different. Let's start with a familiar synchronous function.

import time

def synchronous_task(task_id: int, delay: int):
    print(f"Sync task {task_id}: starting, will sleep for {delay}s.")
    time.sleep(delay) # This is a blocking call
    print(f"Sync task {task_id}: finished.")
    return f"Result of task {task_id}"

To turn this into an asynchronous equivalent, we use async def and replace any blocking I/O calls (like time.sleep) with their non-blocking counterparts (like asyncio.sleep).

import asyncio

async def asynchronous_task(task_id: int, delay: int):
    print(f"Async task {task_id}: starting, will sleep for {delay}s.")
    await asyncio.sleep(delay) # This is a non-blocking call
    print(f"Async task {task_id}: finished.")
    return f"Result of task {task_id}"

Here's the most critical distinction:

• Calling synchronous_task(1, 2) runs the function and returns its result after 2 seconds.
• Calling asynchronous_task(1, 2) does not run the function. Instead, it immediately returns a coroutine object.

Think of a coroutine object as a blueprint or a recipe for a task. It describes what needs to be done, but nothing happens until you explicitly tell the event loop to execute it using the await keyword.

To run a top-level coroutine, we use asyncio.run(), which starts the event loop, runs our coroutine until it's complete, and then closes the loop.

async def main():
    print("Starting the main coroutine.")



    # Here, we 'await' the coroutine object to execute it
    result = await asynchronous_task(1, 2) 
    print(f"Received: {result}")
    print("Main coroutine finished.")

if __name__ == "__main__":
    asyncio.run(main())

Running this script will produce output showing that the asynchronous_task is executed only when await is called.

For a detailed walkthrough of this terminology—event loop, async def, await, coroutine functions, and coroutine objects—the following video is an excellent guide.

The Pitfall: Sequential await

Now that we can run a single coroutine, let's try running two. A common first attempt looks like this:

import asyncio
import time




# (asynchronous_task definition from above)

async def main_sequential():
    start_time = time.time()
    
    print("Running tasks sequentially...")
    result1 = await asynchronous_task(1, 2)
    result2 = await asynchronous_task(2, 3)
    
    end_time = time.time()
    print(f"Main sequential finished in {end_time - start_time:.2f} seconds.")
    print(f"Results: {[result1, result2]}")

if __name__ == "__main__":
    asyncio.run(main_sequential())

If you run this, you'll see an output like this:

Running tasks sequentially...
Async task 1: starting, will sleep for 2s.
Async task 1: finished.
Async task 2: starting, will sleep for 3s.
Async task 2: finished.
Main sequential finished in 5.01 seconds.
Results: ['Result of task 1', 'Result of task 2']

Notice the total time is ~5 seconds (2 + 3). Even though we're using async/await, the code behaves synchronously. We await the first task to its completion before even starting the second one. We haven't achieved concurrency. This is like the "juggling cook" deciding to make one full burger from start to finish before even looking at the next customer's order.

The following video includes a superb animation that visualizes why this approach fails to provide any concurrency benefit.

The Solution: Concurrent Execution with asyncio.gather

To run our tasks concurrently, we need to give all our coroutine "recipes" to the event loop at once and then wait for them all to finish. The primary tool for this is asyncio.gather.

Here's how we modify our main function:

import asyncio
import time




# (asynchronous_task definition from above)

async def main_concurrent():
    start_time = time.time()

    print("Running tasks concurrently...")
    



    # 1. Create a list of coroutine objects (the "recipes"). No code is run yet.
    tasks_to_run = [
        asynchronous_task(1, 2),
        asynchronous_task(2, 3)
    ]
    



    # 2. Use asyncio.gather to schedule and run them all concurrently.
    # The '*' unpacks the list into separate arguments for gather.
    results = await asyncio.gather(*tasks_to_run)
    
    end_time = time.time()
    print(f"Main concurrent finished in {end_time - start_time:.2f} seconds.")
    print(f"Results: {results}")

if __name__ == "__main__":
    asyncio.run(main_concurrent())

Now, the output will look drastically different:

Running tasks concurrently...
Async task 1: starting, will sleep for 2s.
Async task 2: starting, will sleep for 3s.
Async task 1: finished.
Async task 2: finished.
Main concurrent finished in 3.01 seconds.
Results: ['Result of task 1', 'Result of task 2']

Both tasks start almost simultaneously. The event loop runs task 1, sees it await asyncio.sleep(2), and while task 1 is sleeping, it switches to task 2. It runs task 2, sees it await asyncio.sleep(3), and now both are sleeping. After 2 seconds, task 1 finishes. After 3 seconds, task 2 finishes. The total time is determined by the longest-running task (3 seconds), not the sum of all tasks. This is the power of concurrency.

To understand gather and other ways to run tasks, let's watch one more clip.

Your Turn: A Full Comparison

Let's bring it all together. The article below provides a fantastic, self-contained example comparing a synchronous script to a concurrent one using asyncio.gather, just like we did.

Conclusion

You've now taken your first practical steps into writing asynchronous Python code. This is the foundational skill for building high-performance FastAPI applications.

Key Takeaways:

• An async def function, when called, returns a coroutine object—a recipe for a task.
• The await keyword is used inside an async function to pause its execution and run an awaitable object, like another coroutine.
• Awaiting coroutines sequentially (await task1, then await task2) results in sequential execution, not concurrency.
• asyncio.gather is the key to concurrency. It takes multiple coroutines and schedules them on the event loop to run at the same time, switching between them during I/O-bound waits.

You've moved from understanding the idea of concurrency to implementing it. In our next lesson, we will apply this knowledge directly within FastAPI. We'll explore the practical implications of choosing between async def and def for your route handlers and see exactly how FastAPI handles both to maximize performance.