Python 异步编程：asyncio 库的使用——从原理到实战的异步之旅

引言：为什么说“异步编程是高并发的终极武器”？

在传统的同步编程中，程序按顺序执行，遇到I/O操作（如网络请求、文件读写）时会阻塞等待，导致CPU空闲。例如，一个同时处理100个HTTP请求的同步程序，实际耗时可能是单个请求的100倍——这在高并发场景（如电商秒杀、API接口）中完全不可接受。

Python的asyncio库通过异步编程（Asynchronous Programming）解决了这一问题。它基于“协程（Coroutine）”和“事件循环（Event Loop）”机制，让程序在等待I/O时切换执行其他任务，从而将CPU利用率提升数倍甚至数十倍。本文将从0到1带你掌握asyncio的核心用法。

一、异步编程：用“非阻塞”打破时间的枷锁

1.1 同步 vs 异步：两种编程模式的本质区别

• 同步编程：程序按顺序执行，遇到I/O操作时等待完成后再继续（如time.sleep(10)会让程序卡住10秒）；
• 异步编程：遇到I/O操作时主动让出控制权，允许事件循环调度其他任务执行（如等待HTTP响应时，去处理另一个请求）。

类比理解：

• 同步编程像“单线程排队吃饭”：一个人吃完，下一个才能吃；
• 异步编程像“多任务厨师”：炒第一道菜时，同时准备第二道菜的食材，锅铲不闲置。

1.2 异步编程的三大优势

1.3 asyncio的核心组件

asyncio是Python标准库中实现异步编程的核心工具，其核心组件包括：

• 事件循环（Event Loop）：异步程序的“大脑”，负责调度协程、处理I/O事件；
• 协程（Coroutine）：由async def定义的异步函数，通过await暂停执行并让出控制权；
• 任务（Task）：协程的“包装器”，用于在事件循环中调度执行；
• Future：表示异步操作的结果（类似JavaScript的Promise）。

二、asyncio基础：从协程到事件循环的“三步入门”

2.1 第一步：定义协程函数（Coroutine Function）

协程函数通过async def关键字定义，内部用await暂停执行并等待异步操作完成（如I/O）。

示例1：一个简单的协程

import asyncio

async def greet(name: str, delay: int):
    print(f"[{name}] 开始执行（等待{delay}秒）")
    await asyncio.sleep(delay)  # 模拟I/O操作（非阻塞）
    print(f"[{name}] 执行完成！")

关键说明：

• await asyncio.sleep(delay)不会阻塞线程，而是告诉事件循环：“我要等delay秒，期间可以执行其他任务”；
• 协程函数调用后返回一个协程对象（如greet("任务A", 2)返回协程对象，不会立即执行）。

2.2 第二步：创建事件循环（Event Loop）

事件循环是异步程序的“心脏”，负责管理所有异步任务的执行顺序。Python 3.7+提供了简化的asyncio.run()函数，自动创建和关闭事件循环。

示例2：运行单个协程

async def main():
    await greet("任务A", 2)  # 等待协程执行完成

asyncio.run(main())  # 启动事件循环

输出结果：

[任务A] 开始执行（等待2秒）
[任务A] 执行完成！  # 2秒后输出

2.3 第三步：并发执行多个任务

通过asyncio.gather()或asyncio.create_task()可以并发执行多个协程，充分利用异步优势。

示例3：并发执行3个任务

async def main():
    # 创建3个协程对象
    task1 = greet("任务A", 2)
    task2 = greet("任务B", 1)
    task3 = greet("任务C", 3)

    # 并发执行（总耗时≈最长任务时间3秒）
    await asyncio.gather(task1, task2, task3)

asyncio.run(main())

输出结果（时间线）：

[任务A] 开始执行（等待2秒）  # 0秒
[任务B] 开始执行（等待1秒）  # 0秒
[任务C] 开始执行（等待3秒）  # 0秒
[任务B] 执行完成！          # 1秒后（任务B先完成）
[任务A] 执行完成！          # 2秒后（任务A完成）
[任务C] 执行完成！          # 3秒后（任务C完成）

关键结论：

• 总耗时由最长任务（3秒）决定，而非任务时间之和（2+1+3=6秒）；
• asyncio.gather()会等待所有任务完成，返回一个包含所有结果的列表（若任务有返回值）。

三、进阶操作：任务管理与异常处理

3.1 手动创建任务（Task）

asyncio.create_task()可以将协程包装为任务，并立即加入事件循环调度（无需等待await）。

示例4：动态创建任务

async def main():
    print("主任务开始")
    # 创建任务（立即调度，无需等待）
    task = asyncio.create_task(greet("后台任务", 2))
    print("主任务继续执行...")
    await asyncio.sleep(1)  # 主任务执行其他操作（耗时1秒）
    print("主任务结束，等待后台任务完成")
    await task  # 等待后台任务完成

asyncio.run(main())

输出结果（时间线）：

主任务开始
主任务继续执行...          # 0秒（任务已创建，开始执行）
[后台任务] 开始执行（等待2秒）  # 0秒（任务启动）
（等待1秒）
主任务结束，等待后台任务完成  # 1秒后
（再等待1秒）
[后台任务] 执行完成！        # 2秒后（总耗时2秒）

3.2 处理异步异常

异步任务中的异常不会直接抛出，需通过try/except或Task.exception()捕获。

示例5：捕获任务异常

async def risky_task():
    await asyncio.sleep(1)
    raise ValueError("这是一个模拟异常")

async def main():
    task = asyncio.create_task(risky_task())
    try:
        await task  # 等待任务执行，异常在此处抛出
    except ValueError as e:
        print(f"捕获到异常：{e}")

asyncio.run(main())  # 输出：捕获到异常：这是一个模拟异常

3.3 取消未完成的任务

通过Task.cancel()可以取消未完成的任务（如用户超时取消请求）。

示例6：取消任务

async def long_task():
    try:
        await asyncio.sleep(10)  # 模拟耗时10秒的任务
        print("任务完成")
    except asyncio.CancelledError:
        print("任务被取消")

async def main():
    task = asyncio.create_task(long_task())
    await asyncio.sleep(2)  # 等待2秒后取消任务
    task.cancel()
    await task  # 等待任务确认取消（会抛出CancelledError）

asyncio.run(main())  # 输出：任务被取消

四、实战案例：用asyncio优化HTTP请求

4.1 场景描述

某爬虫程序需要获取10个API接口的数据（每个接口耗时约1秒），同步模式下总耗时10秒。使用asyncio+aiohttp（异步HTTP库）可将总耗时缩短至约1秒（并发执行）。

4.2 代码实现

（1）安装依赖

pip install aiohttp  # 异步HTTP客户端

（2）异步爬虫代码

import asyncio
import aiohttp

async def fetch_url(session: aiohttp.ClientSession, url: str):
    async with session.get(url) as response:
        return await response.text()  # 异步读取响应内容

async def main():
    urls = [f"https://api.example.com/data/{i}" for i in range(1, 11)]  # 10个URL

    async with aiohttp.ClientSession() as session:
        # 创建10个任务（并发请求）
        tasks = [fetch_url(session, url) for url in urls]
        # 等待所有任务完成（总耗时≈1秒）
        results = await asyncio.gather(*tasks)

        # 输出结果长度（验证是否成功）
        for i, result in enumerate(results):
            print(f"URL {i+1} 响应长度：{len(result)}")

asyncio.run(main())

4.3 性能对比

五、避坑指南：asyncio的5大常见错误

1. 在协程中使用同步I/O：
   错误示例：time.sleep(2)（阻塞事件循环）；
   正确做法：await asyncio.sleep(2)（非阻塞）。

2. 忘记await关键字：
   错误示例：greet("任务A", 2)（协程对象未被调度，不会执行）；
   正确做法：await greet("任务A", 2)或asyncio.create_task(greet(...))。

3. 事件循环未正确关闭：
   错误示例：手动创建事件循环但未关闭（loop.close()）；
   正确做法：使用asyncio.run()（自动管理循环生命周期）。

4. 混合使用同步和异步代码：
   错误场景：在异步函数中调用同步数据库查询（如pymysql.connect()），导致事件循环阻塞；
   正确做法：使用异步数据库驱动（如asyncpg、aiomysql）。

5. 任务泄露（Task Leak）：
   错误场景：创建任务但未等待完成（如未await task），导致任务未执行且无法捕获异常；
   正确做法：始终通过await或asyncio.gather()等待所有任务。

结语：异步编程是I/O密集型任务的“性能引擎”

通过本文的学习，你已掌握asyncio的核心用法——从协程定义到事件循环调度，再到并发任务管理。asyncio的优势在I/O密集型场景（如网络请求、文件读写）中尤为明显，能将程序性能提升数倍。

但需注意：异步编程并非“万能药”——对于CPU密集型任务（如大量计算），多线程/多进程仍是更好的选择（Python的GIL限制了异步在CPU密集型任务中的表现）。

下一次遇到高并发I/O场景时，记得问自己：“用asyncio了吗？”——这可能是你程序性能的关键突破口！