Getting Started with Python’s asyncio Library

Image by Author | Canva

Asynchronous programming is a powerful technique that enhances the performance of applications. It allows you to perform multiple tasks simultaneously without the need to manage threads or processes manually. This approach is particularly useful for developers working on operations such as sending API requests, fetching files, or interacting with databases, all without pausing the rest of the application. In Python, the most prominent library for asynchronous programming is asyncio. This library manages the execution of programming units by implementing event loops, coroutines, and non-blocking I/O. For developers aiming to build highly responsive and scalable applications, exploring this library is highly recommended.

Before discussing asyncio, you need to have a clear understanding of what asynchronous programming is and how it differs from synchronous programming.

Synchronous Vs Asynchronous Programming

 
In synchronous programming, tasks are executed sequentially, meaning each task must be completed before the next one can begin. The image below shows how synchronous programs work.
 

 
Asynchronous programming, on the contrary, allows multiple tasks to run simultaneously. While one task is waiting for a slow operation (like fetching data from a server), the program can proceed to work on other tasks. This ‘non-blocking’ approach prevents the program from stalling and makes much better use of available resources, resulting in faster overall execution. The image below shows the working of asynchronous programs.
 

What is asyncio?

 
It provides a framework for writing asynchronous code using the async and await syntax. It allows your program to make network requests, access files, and many operations without halting other processes. This way, your program can stay responsive, while waiting for some operations to finish. There is no need to install asyncio as it is included by default in Python version 3.3 and above.

Components

 
The key components are:

• Event loop: Manages and schedules asynchronous tasks and coroutines.
• Coroutines: These are special functions defined using async def and can pause their execution with the await keyword. This enables other tasks to run while they wait for results.
• Tasks: A task is a coroutine that has been scheduled to run on the event loop. You can create tasks using asyncio.create_task().
• Futures: Represent the result of an operation that may not have been completed yet. They act as placeholders for results that will be available in the future.

Let’s understand the features of asyncio using an example:

Code

import asyncio

async def calculate_square(number):
    print(f"The task started to calculate the square of {number}")
    await asyncio.sleep(1)  # Simulate a delay
    print(f"The task to calculate the square of {number} ended.")
    return number ** 2

async def calculate_cube(number):
    print(f"The task started to calculate the cube of {number}")
    await asyncio.sleep(2)  # Simulate a delay
    print(f"The task to calculate the cube of {number} ended.")
    return number ** 3

async def main():
    # Create tasks and schedule them on the event loop
    task1 = asyncio.create_task(calculate_square(5))  
    task2 = asyncio.create_task(calculate_cube(3))   
    
    # Wait for tasks to finish    
    result1 = await task1
    result2 = await task2
   
    # Now print the results 
    print(f"The square result is: {result1}")  
    print(f"The cube result is: {result2}")   
 
if __name__ == "__main__":

# Start the event loop
    asyncio.run(main())

Key Points

• Event Loop: asyncio.run(main()) starts the event loop and runs the main() coroutine.
• Coroutines: calculate_square(number) and calculate_cube(number) are coroutines. They simulate delays using await asyncio.sleep(), which doesn’t block the entire program. Rather, it tells the event loop to suspend the current task for a given number of seconds and allow other tasks to run during that time.
• Tasks: Inside main(), we create tasks using asyncio.create_task(). This schedules both coroutines (calculate_square(number) and calculate_cube(number)) to run concurrently on the event loop.
• Futures: result1 and result2 are “futures” that represent the results of the tasks. They will eventually hold the results of calculate_square() and calculate_cube() once they are complete.

Output

The task started to calculate the square of 5
The task started to calculate the cube of 3
The task to calculate the square of 5 ended.
The task to calculate the cube of 3 ended.
The square result is: 25
The cube result is: 27

Running Multiple Coroutines – asyncio.gather()

 
asyncio.gather() allows multiple coroutines to run concurrently. This library is mostly used to work with network requests. So, let’s understand concurrency with the help of simulating multiple HTTP requests:
 

Code

import asyncio
# task that fetches data from a URL
async def fetch_data(URL, delay):
    print(f"Starting to fetch data from {URL}")
    await asyncio.sleep(delay)  # Simulate the time delay
    return f"Fetched data from {URL} after {delay} seconds"

# Main coroutine to run multiple fetch tasks concurrently
async def main():
    # Run multiple fetch tasks concurrently
    results = await asyncio.gather(
        fetch_data("https://openai.com", 2),  
        fetch_data("https://github.com", 5),  
        fetch_data("https://python.org", 7)   
    )
    
    # Print the results of all tasks
    for result in results:
        print(result)

asyncio.run(main())

Key Points

• fetch_data(, delay) coroutine simulates fetching data from a URL with a delay. This delay represents the time it takes to retrieve data.
• asyncio.gather() function runs three fetch_data() coroutines concurrently.
• The tasks run concurrently, so the program doesn’t have to wait for one task to finish before starting the next one.

Output

Starting to fetch data from https://openai.com
Starting to fetch data from https://github.com
Starting to fetch data from https://python.org
Fetched data from https://openai.com after 2 seconds
Fetched data from https://github.com after 5 seconds
Fetched data from https://python.org after 7 seconds

Handling Timeouts – asyncio.wait_for()

 
This library also provides a way to handle timeouts using the function asyncio.wait_for(). Let’s understand it with the help of an example:

Code

import asyncio
async def fetch_data():
    await asyncio.sleep(15)  # Simulate a delay
    return "Data fetched"

async def main():
    Try:
        # Set a timeout of 2 seconds
        result = await asyncio.wait_for(fetch_data(), timeout=10) 
        print(result)
    except asyncio.TimeoutError:
        print("Fetching data timed out")

asyncio.run(main())

In this case, if fetch_data() takes more than 10 seconds, a TimeoutError will be raised.

Wrapping Up

 
In short, this guide covers the basics of the library for you and highlights the difference between synchronous and asynchronous programming. I understand writing asynchronous code might be difficult and sometimes even a pain to deal with, but believe me once you get familiar with it, you will understand how many advantages it has to offer. If you are interested in learning more about asyncio do check out its documentation.
 
 

Kanwal Mehreen Kanwal is a machine learning engineer and a technical writer with a profound passion for data science and the intersection of AI with medicine. She co-authored the ebook “Maximizing Productivity with ChatGPT”. As a Google Generation Scholar 2022 for APAC, she champions diversity and academic excellence. She’s also recognized as a Teradata Diversity in Tech Scholar, Mitacs Globalink Research Scholar, and Harvard WeCode Scholar. Kanwal is an ardent advocate for change, having founded FEMCodes to empower women in STEM fields.