Asyncio

Most Python code executes from top to bottom, one step at a time.

That model breaks when your program has to wait on something, like a network call or a file read.

asyncio is Python’s answer. It uses an event loop to run multiple tasks on a single thread. No threads. No processes. Just tasks that pause and resume with async and await.

‍

What Is asyncio

asyncio is a standard library in Python that lets you write asynchronous code. It helps you manage concurrency without using threads or multiple processes.

It’s designed for I/O-bound operations: reading files, making HTTP requests, or waiting for database results. When one task waits, another starts. All in one thread.

At the core of asyncio:

• async def defines a coroutine function
• await pauses a coroutine until the awaited task finishes
• The event loop runs all scheduled tasks
• Tasks and Futures let you coordinate execution

You can:

• Use asyncio.run() to launch the main coroutine
• Use asyncio.gather() to run tasks concurrently
• Use create_task() to schedule background work
• Use TaskGroup to manage related tasks with better structure

‍

Event Loop and Coroutines

The event loop is the engine behind all of it. It runs coroutines, switches between tasks, and resumes work once each pause is over.

Define a coroutine:

‍

‍

But it won't run until you execute:

‍

That starts the event loop and moves everything to completion.

Calling a coroutine function returns a coroutine object. It doesn't execute by default. You must await it or schedule it with create_task().

‍

Example: Concurrent Tasks

‍

This prints "hello" after 1 second, then "world" after 2 seconds. Because they run together, total runtime is 2 seconds. If run sequentially, it would take 3.

‍

Coroutine Objects vs Coroutine Functions

‍

When you call a coroutine function, it returns a coroutine object. It does nothing until you await it.

‍

Using create_task()

‍

create_task() schedules the coroutine to run soon. The event loop takes care of when.

‍

TaskGroup for Structured Concurrency

TaskGroup makes it easier to manage multiple tasks. It waits for all of them to complete. If one fails, it cancels the others.

‍

The async with block ensures all tasks are done or canceled before it exits.

‍

Timeouts and Cancellation

Tasks can be canceled by calling cancel() or by using asyncio.timeout():

‍

‍

Use asyncio.timeout() to limit duration:

‍

Integration with Files, HTTP, and CPU Work

Use async libraries to avoid blocking the event loop.

‍

Async File I/O

‍

‍

Async HTTP Requests

‍

‍

CPU-Bound Work

‍

Use run_in_executor() to handle blocking or CPU-heavy code.

For more parallelism, use ProcessPoolExecutor.

‍

Thread Safety

‍

asyncio is single-threaded. You don’t need to worry about locks unless you add threads yourself.

If coroutines share state, use asyncio.Lock :

‍

Or use asyncio.Queue :

‍

I/O vs CPU: Know the Difference

‍

Use asyncio when waiting. Use processes when computing.

‍

Mixing Async and Blocking Code

‍

Wrap sync functions with run_in_executor() :

Never run blocking code directly inside an async def . It will freeze the loop.

‍

FAQ

‍

What is asyncio in Python?

A library to write concurrent, asynchronous code using async and await . It runs in a single thread using an event loop.

‍

Is asyncio multi-threaded?

No. It uses one thread with cooperative multitasking.

‍

How does it compare to threading or multiprocessing?

• asyncio: single-threaded, best for I/O-bound work
• threading: multiple threads, but harder to manage
• multiprocessing: best for CPU-heavy tasks

‍

When should I use asyncio?

When your code waits on network, files, or database responses. It’s efficient and avoids thread overhead.

‍

What is a coroutine object?

It’s what you get when you call an async def function. You must await or schedule it to run.

‍

What’s the difference between await, gather, and create_task?

• await: waits for a coroutine to finish
• gather: runs several coroutines and waits for all
• create_task: schedules a coroutine to run soon

‍

What is a Future?

A placeholder for a result that’s not ready. Managed by asyncio.

‍

Why use TaskGroup?

To manage a group of tasks with one structure. If one fails, the others are canceled. It simplifies cleanup.

‍

Does asyncio support timeouts and canceling?

Yes. Use task.cancel() or asyncio.timeout() and handle with try/finally.

‍

Can I run blocking code in asyncio?

Yes, but use run_in_executor() to avoid freezing the loop.

‍

Is asyncio good for CPU-bound tasks?

No. Use multiprocessing or a thread pool.

‍

What libraries should I use?

• aiofiles for files
• aiohttp for HTTP
• run_in_executor() for sync code

‍

Is asyncio stable?

Yes. It’s widely used in production systems and actively maintained.

‍

What Python version should I use?

Python 3.7 or newer. That gives you [asyncio.run](<http://asyncio.run/>)(), create_task(), and TaskGroup.

‍

Key Points

asyncio is Python’s built-in tool for writing fast, non-blocking programs.

It is not a thread-based system. It runs an event loop, pauses tasks when they wait, and resumes them when ready. One thread. Many tasks. Maximum efficiency for I/O-heavy workloads.

You’ve learned how to use async def, await, gather, and create_task. You’ve seen TaskGroup for coordination, and run_in_executor() for legacy or CPU-bound work. You know when to use locks or queues. You know the right tools for files, HTTP, and long-running functions.

Use asyncio when your code waits.

Keep blocking code isolated.

Structure your app with clear, predictable task flows.

If your program does a lot of waiting, asyncio makes it move.

‍