备案号:蜀ICP备2026035467号-3 | www.xservx.com

Python协程学习

掌握async/await异步编程核心机制与工程实践

什么是Python协程?为什么它正在重塑异步编程?

协程(coroutine)是Python中一种轻量级的并发编程模型,它基于事件循环实现非阻塞式任务调度。与传统多线程相比,协程在I/O密集型场景下展现出显著性能优势——当一个协程遇到网络请求、文件读写等耗时操作时,无需阻塞整个线程,而是主动让出控制权,让事件循环调度其他就绪任务继续执行,从而极大提升CPU利用率与系统吞吐量。

Python 3.5引入async与await语法,标志着协程从生成器语法糖升级为语言级一等公民;Python 3.7起asyncio模块趋于稳定,配合aiohttp、asyncpg等生态库,已形成完整异步开发栈。当前主流Web框架(如FastAPI、Quart)、数据库驱动(如asyncpg、aiomysql)、HTTP客户端(如httpx)均深度支持异步,协程已成为现代Python开发的必备技能。

⚡ 协程 vs 线程:关键差异对比

  • 调度粒度:协程由用户态调度器管理,线程由操作系统调度;
  • 切换开销:协程上下文切换仅需保存寄存器状态,线程需切换页表、栈等内核资源;
  • 并发上限:单线程可轻松管理数千协程,而线程数受限于系统资源(通常≤1万);
  • 数据共享:协程天然无共享内存,避免锁竞争;线程需显式同步机制;
  • 适用场景:协程适合I/O密集型(网络、磁盘),线程适合CPU密集型(计算、图像处理)。

需特别注意:协程并非银弹。若任务中存在阻塞式操作(如time.sleep()、同步数据库调用),将导致整个事件循环停滞——此时必须使用asyncio.to_thread()或loop.run_in_executor()将阻塞任务移出事件循环线程。

协程核心语法与基础运行机制

Python协程的实现依赖三个核心语法元素:async def定义协程函数,await挂起当前协程等待异步操作完成,asyncio.run()启动顶层事件循环。理解其底层执行模型是掌握异步编程的关键。

import asyncio
async def fetch_data():
    print("开始获取数据...")
    await asyncio.sleep(1)  # 模拟I/O延迟
    print("数据获取完成")
    return {"status": "success", "data": [1, 2, 3]}
async def main():
    result = await fetch_data()
    print("处理结果:", result)
asyncio.run(main())

当执行asyncio.run(main())时,Python执行流程如下:①创建新事件循环;②将main()协程对象注册为顶层任务;③循环调度任务执行;④遇到await asyncio.sleep(1)时,fetch_data协程挂起,事件循环调度其他任务;⑤1秒后唤醒fetch_data并恢复执行。

事件循环本质是一个单线程协作式调度器:所有协程运行于同一OS线程,通过await主动让出控制权实现并发,而非真正并行。

协程状态机解析

协程对象具有四种状态:GEN_CREATED(创建未执行)、GEN_RUNNING(正在执行)、GEN_SUSPENDED(挂起等待)、GEN_CLOSED(执行完毕或异常终止)。可通过inspect.getgeneratorstate()检查状态。

import inspect
async def demo():
    await asyncio.sleep(0.1)
gen = demo()
print(inspect.getgeneratorstate(gen))  # GEN_CREATED
asyncio.run(gen)
print(inspect.getgeneratorstate(gen))  # GEN_CLOSED

协程嵌套与任务并发

多个协程可通过asyncio.gather()并发执行,其本质是创建多个任务对象并等待全部完成。注意:并发不等于并行——所有协程仍在同一线程中协作式执行。

async def task(name, delay):
    print(f"{name} 开始")
    await asyncio.sleep(delay)
    print(f"{name} 结束")
    return f"{name} 完成"
async def main():
    results = await asyncio.gather(
        task("A", 1.2),
        task("B", 0.8),
        task("C", 1.0)
    )
    print("结果:", results)
asyncio.run(main())

执行顺序为:A→B→C(初始启动),随后事件循环按I/O完成顺序唤醒:B先完成→C次之→A最后。输出结果为:B完成→C完成→A完成,最终results顺序与传入顺序一致(按任务ID排序)。

事件循环:协程调度的核心引擎

事件循环(Event Loop)是协程调度的中枢,负责注册任务、监控I/O事件、管理回调队列。Python 3.10起asyncio.run()成为标准入口,但深入理解循环机制对调试与性能优化至关重要。

常用事件循环API

  • asyncio.get_event_loop():获取当前线程的循环对象(3.10+已废弃,建议用asyncio.get_running_loop());
  • asyncio.run(coro):创建新循环执行协程,完成后自动关闭;
  • loop.create_task(coro):创建任务对象并调度执行;
  • loop.run_until_complete(coro):手动控制循环生命周期;
  • loop.call_soon(callback):将回调加入就绪队列,优先级最高。

事件循环工作流程

① 任务注册阶段

通过create_task()或gather()将协程包装为Task对象,加入事件循环的_ready队列;

② I/O监控阶段

使用select/ epoll/ kqueue等系统调用监控文件描述符状态;

③ 回调执行阶段

遍历_ready队列执行就绪任务,遇到await时将协程挂起并注册I/O回调;

④ I/O完成唤醒

当I/O事件触发,事件循环将对应任务移入_ready队列,等待下一轮调度。

事件循环默认使用单线程执行所有任务。若需并行计算,需结合concurrent.futures.ThreadPoolExecutor或ProcessPoolExecutor。

事件循环最佳实践

  • 始终通过asyncio.run()启动顶层协程,避免手动管理循环生命周期;
  • 循环中禁止阻塞操作(如time.sleep()、同步网络请求);
  • 长时间运行任务应拆分为多个await asyncio.sleep(0)点主动让出控制权;
  • 使用loop.set_debug(True)开启调试模式,捕获慢回调与资源泄漏。

async/await原理深度剖析

从字节码层面看,async def定义的协程函数在编译时生成特殊协程对象(types.CoroutineType),其__await__()方法返回迭代器。当await表达式求值时,Python调用被等待对象的__await__()方法获取迭代器,并通过.send(None)驱动协程执行。

import types
async def my_coro():
    return 42
coro = my_coro()
print(type(coro))  # <class 'coroutine'>
print(isinstance(coro, types.CoroutineType))  # True
# 等价于:
gen = coro.__await__()
print(next(gen))  # RuntimeError: cannot reuse already awaited coroutine

awaitable对象的三种类型

1. 协程对象(Coroutine)

async def函数调用返回的对象,可通过await等待其完成。

2. 生成器(Generator)

使用@asyncio.coroutine装饰的生成器(Python 3.10+废弃),内部通过yield from挂起。

3. Future对象

asyncio.Future表示异步操作的结果,是事件循环调度的基本单元。所有await表达式最终都会等待Future完成。

协程调度器实现模拟

class SimpleScheduler:
    def __init__(self):
        self.tasks = []
    def add_task(self, coro):
        self.tasks.append(coro)
    def run_until_complete(self):
        while self.tasks:
            coro = self.tasks.pop(0)
            try:
                coro.send(None)  # 驱动协程执行
                self.tasks.append(coro)  # 重新加入队列
            except StopIteration:
                pass  # 协程完成
# 使用示例
async def task1():
    print("T1-1")
    await asyncio.sleep(0.1)
    print("T1-2")
async def task2():
    print("T2-1")
    await asyncio.sleep(0.1)
    print("T2-2")
scheduler = SimpleScheduler()
scheduler.add_task(task1())
scheduler.add_task(task2())
scheduler.run_until_complete()

注意:实际asyncio调度器远比此复杂,包含优先级队列、I/O轮询、信号处理等模块,此处仅为原理演示。

aiohttp实战:构建高性能异步HTTP服务

aiohttp是Python生态中最成熟的异步HTTP框架,支持服务端与客户端开发。其核心优势在于:单进程可处理数万并发连接,I/O等待时不阻塞主线程,特别适合API网关、实时通信服务。

异步HTTP客户端示例

import aiohttp
import asyncio
async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()
async def main():
    urls = [
        "https://httpbin.org/get?delay=1",
        "https://httpbin.org/get?delay=2",
        "https://httpbin.org/get?delay=1.5"
    ]
    tasks = [fetch(url) for url in urls]
    responses = await asyncio.gather(*tasks)
    print(f"共获取 {len(responses)} 个响应")
    for i, resp in enumerate(responses):
        print(f"响应 {i+1} 长度:{len(resp)} 字符")
asyncio.run(main())

关键点解析:ClientSession管理连接池与Cookie,async with确保资源自动释放,await response.text()将响应体解码为字符串(自动处理gzip/deflate压缩)。

⚠️ 避免在循环内创建ClientSession!应复用会话对象以复用TCP连接,否则每次请求需重新建立TLS握手,性能下降10倍以上。

异步服务端开发

from aiohttp import web
async def handle(request):
    name = request.match_info.get('name', "Anonymous")
    await asyncio.sleep(0.5)  # 模拟耗时操作
    text = f"Hello, {name}!"
    return web.Response(text=text)
app = web.Application()
app.add_routes([web.get('/', handle),
                web.get('/{name}', handle)])
web.run_app(app, host='127.0.0.1', port=8080)

启动后访问http://localhost:8080/Python,即使await asyncio.sleep(0.5)阻塞当前协程,其他请求仍可正常处理(通过事件循环调度)。

异步数据库操作:asyncpg与aiomysql

同步数据库驱动(如psycopg2)会阻塞事件循环,必须使用异步驱动。主流方案:asyncpg(PostgreSQL)、aiomysql(MySQL),二者API高度一致。

asyncpg连接池实战

import asyncpg
import asyncio
async def main():
    pool = await asyncpg.create_pool(
        user='postgres', password='123456',
        database='testdb', host='127.0.0.1'
    )
    async with pool.acquire() as conn:
        # 插入数据
        await conn.execute(
            "INSERT INTO users(name, email) VALUES($1, $2)",
            "张三", "zhangsan@example.com"
        )
        # 查询数据
        rows = await conn.fetch(
            "SELECT * FROM users WHERE name LIKE $1",
            "张%"
        )
        for row in rows:
            print(dict(row))
    await pool.close()
asyncio.run(main())

连接池关键优势:
① 复用物理连接,避免频繁建立/关闭;
② 自动管理连接生命周期;
③ 支持连接池大小动态调整(min_size与max_size参数)。

⚠️ 每个协程应独立获取连接(通过pool.acquire()),禁止跨协程共享连接对象,否则导致连接状态混乱。

事务与异常处理

async def transfer(pool, from_id, to_id, amount):
    async with pool.acquire() as conn:
        async with conn.transaction():  # 自动提交/回滚
            await conn.execute(
                "UPDATE accounts SET balance = balance - $1 WHERE id = $2",
                amount, from_id
            )
            # 模拟异常:余额不足
            if amount > 1000:
                raise ValueError("Insufficient balance")
            await conn.execute(
                "UPDATE accounts SET balance = balance + $1 WHERE id = $2",
                amount, to_id
            )

conn.transaction()上下文管理器确保事务原子性:成功时自动提交,异常时自动回滚。

协程池设计:资源管控与性能优化

直接并发启动大量协程会导致资源耗尽(如数据库连接数超限、网络端口耗尽)。协程池通过限制并发数量,平衡吞吐量与稳定性。

信号量控制并发数

import asyncio
import aiohttp
async def fetch_with_semaphore(sem, session, url):
    async with sem:  # 获取信号量
        async with session.get(url) as resp:
            return await resp.text()
async def main():
    urls = ["https://httpbin.org/delay/1"] * 100
    sem = asyncio.Semaphore(10)  # 最大并发10
    async with aiohttp.ClientSession() as session:
        tasks = [
            fetch_with_semaphore(sem, session, url)
            for url in urls
        ]
        results = await asyncio.gather(*tasks)
    print(f"成功处理 {len(results)} 个请求")
asyncio.run(main())

自定义协程池实现

class CoroutinePool:
    def __init__(self, max_size=10):
        self.max_size = max_size
        self.semaphore = asyncio.Semaphore(max_size)
    async def run(self, coro_func, *args):
        async with self.semaphore:
            return await coro_func(*args)
async def worker(name, delay):
    print(f"{name} 开始工作")
    await asyncio.sleep(delay)
    return f"{name} 完成"
async def main():
    pool = CoroutinePool(max_size=3)
    tasks = [
        pool.run(worker, f"任务{i}", i*0.5)
        for i in range(5)
    ]
    results = await asyncio.gather(*tasks)
    print("结果:", results)
asyncio.run(main())

输出显示:同时最多3个任务在执行(任务0→任务1→任务2启动),后续任务需等待信号量释放。

异步调试:定位常见陷阱与错误

协程调试比同步代码更复杂,常见问题包括:RuntimeWarning: coroutine 'xxx' was never awaited(忘记await)、事件循环已关闭、资源泄漏等。

高频错误场景

  • 未await协程:asyncio.run(my_coro())正确,但my_coro()单独调用会返回协程对象未执行;
  • 阻塞事件循环:time.sleep(1)应替换为await asyncio.sleep(1);
  • 循环已关闭:重复调用asyncio.run()会报错,应复用循环或用asyncio.get_event_loop().run_until_complete();
  • 资源未释放:async with session.get()未使用async with导致连接泄漏。

调试工具与技巧

  • loop.set_debug(True):启用调试模式,记录慢回调(>1s)与资源泄漏;
  • asyncio.run(main(), debug=True):3.8+直接传参启用调试;
  • asyncio.all_tasks():检查未完成任务;
  • 使用tracemalloc检测内存泄漏:import tracemalloc; tracemalloc.start()。

协程开发技巧与工程实践

① 超时控制

使用asyncio.wait_for()防止无限等待:

async def fetch_with_timeout(url, timeout=2):
    try:
        return await asyncio.wait_for(fetch(url), timeout)
    except asyncio.TimeoutError:
        print("请求超时")
        return None

② 取消任务

task.cancel()发送取消信号,协程需处理asyncio.CancelledError:

async def cancellable_task():
    try:
        await asyncio.sleep(10)
    except asyncio.CancelledError:
        print("任务被取消")
        raise  # 重新抛出以完成取消
task = asyncio.create_task(cancellable_task())
await asyncio.sleep(1)
task.cancel()
await task

③ 上下文变量

使用contextvars管理协程内状态,避免全局变量竞争:

import contextvars
request_id = contextvars.ContextVar("request_id", default="unknown")
async def handler():
    request_id.set("req-123")
    await process()
async def process():
    print(f"处理请求:{request_id.get()}")  # req-123
asyncio.run(handler())