asyncio in Python

Introduction to asyncio in Python

Python’s asyncio library provides a foundation for writing asynchronous code using the async/await syntax. It’s especially useful for applications that perform network operations, file I/O, or other time-consuming tasks that would normally block the program’s execution.

What is Asynchronous Programming?

Asynchronous programming allows your code to handle multiple operations at once. Rather than waiting for one task to finish before moving to the next, Python can switch between tasks when one is waiting—leading to improved performance and responsiveness, particularly in I/O-bound programs.

Understanding the Event Loop

The core of asyncio is the event loop. It acts like a manager that keeps track of tasks and runs them when they're ready. When a coroutine yields control, the event loop takes over and decides what to run next.

import asyncio

async def say_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(say_hello())

Coroutines in Python

A coroutine is a special function defined with async def that can pause its execution with await. When a coroutine encounters await, it yields control back to the event loop, allowing other tasks to run in the meantime.

Running Multiple Tasks Concurrently

You can use asyncio.gather() to run multiple coroutines in parallel. This is helpful when you have multiple independent I/O operations that can happen at the same time.

import asyncio

async def task(name, delay):
    print(f"Starting {name}")
    await asyncio.sleep(delay)
    print(f"Finished {name}")

async def main():
    await asyncio.gather(
        task("Task 1", 2),
        task("Task 2", 1)
    )

asyncio.run(main())

Using asyncio.sleep()

The asyncio.sleep() function is a non-blocking way to pause execution for a set amount of time. Unlike time.sleep(), it lets other tasks run while waiting.

Combining Synchronous and Asynchronous Code

Sometimes, you might need to run blocking code within an async program. In such cases, use run_in_executor() to execute blocking functions in a separate thread or process without freezing the event loop.

import asyncio
import time

def blocking_task():
    time.sleep(3)
    print("Blocking task completed")

async def main():
    loop = asyncio.get_running_loop()
    await loop.run_in_executor(None, blocking_task)

asyncio.run(main())

Conclusion

The asyncio module in Python brings the power of asynchronous programming to your applications. By using coroutines, event loops, and non-blocking I/O, you can build efficient and high-performing programs—especially when dealing with multiple I/O operations.