Python 异步编程指南

异步编程是 Python 高性能的关键。深入理解 async/await，写出高效的并发代码。

为什么需要异步？

同步代码的问题：

import time

def fetch_data():
    time.sleep(2)  # 阻塞 2 秒
    return "data"

# 串行执行，总共 6 秒
fetch_data()
fetch_data()
fetch_data()

异步方案：

import asyncio

async def fetch_data():
    await asyncio.sleep(2)  # 非阻塞
    return "data"

# 并发执行，总共 2 秒
async def main():
    results = await asyncio.gather(
        fetch_data(),
        fetch_data(),
        fetch_data()
    )

asyncio.run(main())

核心概念

async 和 await

• async：定义协程函数
• await：等待协程完成

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

Event Loop

事件循环是异步的核心，调度协程执行。

# 手动创建事件循环
loop = asyncio.get_event_loop()
loop.run_until_complete(say_hello())
loop.close()

实战场景

并发 HTTP 请求

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = ["http://example.com"] * 10
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        print(f"获取 {len(results)} 个页面")

asyncio.run(main())

异步数据库操作

import asyncpg

async def query_db():
    conn = await asyncpg.connect(
        "postgresql://user:pass@localhost/db"
    )
    rows = await conn.fetch("SELECT * FROM users")
    await conn.close()
    return rows

定时任务

async def periodic_task():
    while True:
        print("执行任务...")
        await asyncio.sleep(60)  # 每分钟

async def main():
    await asyncio.gather(
        periodic_task(),
        another_task()
    )

常见陷阱

1. 阻塞事件循环

# ❌ 错误：time.sleep 阻塞
async def bad():
    time.sleep(1)

# ✅ 正确
async def good():
    await asyncio.sleep(1)

2. 忘记 await

# ❌ 错误
result = fetch_data()  # 返回协程对象

# ✅ 正确
result = await fetch_data()

3. 异常处理

async def safe_fetch():
    try:
        return await fetch_data()
    except Exception as e:
        print(f"错误：{e}")
        return None

性能对比

同步 vs 异步（100 个请求）：

• 同步：~200 秒
• 异步：~2 秒

提升 100 倍！

最佳实践

1. IO 密集型用异步（网络、数据库、文件）
2. CPU 密集型用多进程（异步不提升 CPU 性能）
3. 使用 asyncio.gather 并发
4. 设置超时避免 hangs

await asyncio.wait_for(fetch(), timeout=5.0)

异步编程是 Python 高级开发的必备技能，掌握它能大幅提升程序性能！