Python's asyncio library implements concurrent programming through coroutines, and uses async/await syntax to improve code readability. First, define coroutines with async def and pause execution through await to release control of the event loop; second, use asyncio.run() to start the event loop and run the main function; finally, perform multiple tasks concurrently through asyncio.gather() or create_task(). In actual applications, I/O operations should be encapsulated as coroutines, such as using aiohttp for network requests, and be careful to avoid blocking calls and managing shared state.

Python's asyncio library is built around the concept of coroutines — functions that can pause and resume their execution. With async/await syntax, writing concurrent code becomes more readable and manageable. Here's how to make it work.

Understanding Async IO Basics

At its core, asyncio uses an event loop to manage and execute asynchronous tasks. You define functions with async def , which makes them coroutines. When you call one of these functions, it doesn't run immediately — instead, it returns a coroutine object that needs to be awaited or scheduled on the event loop.

 import asyncio

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

asyncio.run(say_hello())

This simple example shows the structure: the function is declared with async def , uses await to wait for another coroutine (like asyncio.sleep() ), and is executed using asyncio.run() .

Key points:

• async def defines a coroutine.
• await hands control back to the event loop until the awaited task completes.
• asyncio.run() manages the event loop in modern Python versions (3.7).

Running Multiple Tasks Concurrently

To run multiple tasks at once, use asyncio.gather() or asyncio.create_task() . These allow your program to perform I/O-bound operations in parallel — like making several HTTP requests or reading multiple files.

Here's how you can run three instances of the earlier function concurrently:

 async def main():
    await asyncio.gather(
        say_hello(),
        say_hello(),
        say_hello()
    )

asyncio.run(main())

You'll notice all "Hello" messages appear first, then after a second, all "World" messages — this shows the concurrency.

Tips:

• Use create_task() inside a function to schedule tasks early and start working on them right away.
• Don't forget to await tasks if you need their results.
• Avoid blocking calls like time.sleep() ; stick with await asyncio.sleep() .

Structuring Real-World Applications

For real applications, especially ones involving network requests or database queries, organize your code so each independent operation runs as a coroutine.

Let's say you're fetching data from multiple URLs:

 async def fetch_data(url):
    print(f"Fetching {url}")
    await asyncio.sleep(1) # Simulate network delay
    print(f"Done with {url}")

async def main():
    urls = ["https://example.com", "https://example.org", "https://example.net"]
    tasks = [fetch_data(url) for url in urls]
    await asyncio.gather(*tasks)

asyncio.run(main())

In this case, each fetch_data() call represents a separate I/O operation. By running them concurrently, you save time compared to doing them one after another.

When building larger apps:

• Keep I/O-bound operations as coroutines.
• Use connection pools or async libraries like aiohttp for HTTP clients.
• Be cautious about shared state — async doesn't automatically make your code thread-safe.

That's how asyncio and async/await work together to help you write efficient, non-blocking code. It takes some getting used to, but once you structure your I/O-heavy tasks this way, performance usually improves noticeably.

The above is the detailed content of How can Python's asyncio library be used to write concurrent code using async/await syntax?. For more information, please follow other related articles on the PHP Chinese website!