当前位置：首页>python>Python异步编程实战:从async/await到Future对象,彻底搞懂协程并发

Python异步编程实战:从async/await到Future对象,彻底搞懂协程并发

  • 2026-10-11 07:36:05
Python异步编程实战:从async/await到Future对象,彻底搞懂协程并发

引言

你是否曾因Python程序在等待网络请求或文件读写时“卡住”而烦恼？同步编程中，一个阻塞操作就会让整个程序停滞，用户体验和系统吞吐量大打折扣。异步编程正是解决这一痛点的利器，它允许程序在等待I/O时切换到其他任务，极大提升并发效率。本文将带你深入Python异步编程的核心，从async/await的基础用法，一直剖析到Future对象的底层原理，让你不仅会用，更能理解其工作机制。掌握这些，你就能轻松编写出高性能、高响应的Python应用。

一、异步编程基础：async/await详解

1.1 异步函数与普通函数的本质区别

在Python中，使用 async def 定义的是异步函数（协程函数）。它不能像普通函数那样直接调用执行，而是返回一个协程对象（coroutine object），需要由事件循环（event loop）来调度执行。

import asyncio# 定义一个异步函数（协程函数）async def async_task():    print("这是一个异步函数，不能像普通函数一样直接调用执行")# 定义一个普通函数def normal_task():    print("这是一个普通函数，能够被直接调用")def demo():    # 调用普通函数    normal_result = normal_task()    print(f"普通函数调用结果类型: {type(normal_result)}")  # 输出: <class 'NoneType'>    # 错误调用：直接调用异步函数    async_result = async_task()  # 这里不会执行函数体，只是创建协程对象    print(f"异步函数直接调用结果类型: {type(async_result)}")  # 输出: <class 'coroutine'>if __name__ == '__main__':    demo()

运行上述代码会看到警告信息：

RuntimeWarning: coroutine 'async_task' was never awaited  demo()RuntimeWarning: Enable tracemalloc to get the object allocation traceback

这个警告明确告诉我们：协程对象没有被等待（await），异步函数根本没有执行。

1.2 正确执行异步函数的方法

要执行异步函数，必须通过事件循环来调度。最简单的方式是使用 asyncio.run()：

import asyncioasync def async_task():    print("这是一个异步函数，现在通过事件循环正确执行了")def normal_task():    print("这是一个普通函数，能够被直接调用")def demo():    # 通过asyncio.run()执行异步函数    asyncio.run(async_task())if __name__ == '__main__':    demo()

输出结果：

这是一个异步函数，现在通过事件循环正确执行了

1.3 await关键字：异步编程的核心

await 关键字只能在异步函数内部使用。它的作用是：挂起当前协程，让出控制权给事件循环，事件循环可以调度其他任务执行。

import asyncioimport timeasync def task1():    """模拟一个需要多次I/O操作的任务"""    print("task1开始执行")    await asyncio.sleep(5)  # 第一次挂起，模拟5秒I/O    await asyncio.sleep(5)  # 第二次挂起    await asyncio.sleep(5)  # 第三次挂起    await asyncio.sleep(5)  # 第四次挂起    print("task1执行结束")    return 10async def task2():    """模拟另一个I/O任务"""    print("task2开始执行")    await asyncio.sleep(10)    print("task2执行结束")    return 20async def task3():    print("task3开始执行")    await asyncio.sleep(3)    print("task3执行结束")    return 30async def task4():    print("task4开始执行")    await asyncio.sleep(2)    print("task4执行结束")    return 40async def main():    """主函数，并发执行多个任务"""    print("main函数开始")    # 使用asyncio.gather并发执行多个任务    results = await asyncio.gather(task1(), task2(), task3(), task4())    print(f"所有任务结果: {results}")if __name__ == '__main__':    start_time = time.time()    asyncio.run(main())    end_time = time.time()    time_consuming = end_time - start_time    print(f"总耗时: {time_consuming:.2f}秒")

1.4 await的使用规则与注意事项

  1. await后面必须跟"可等待对象"
    ：包括协程对象、Future对象、Task对象等
  2. await让出控制权
    ：当遇到await时，当前协程会暂停，事件循环可以执行其他任务
  3. await不是立即切换
    ：如果await后面是协程函数，会先执行该协程，直到遇到它内部的await才会真正切换
import asyncioimport timeasync def sub_task1():    """子任务1：演示await链式调用"""    return_value = 100    sleep_time = 3    await asyncio.sleep(sleep_time)    print(f"子任务1完成，返回值: {return_value}, 耗时: {sleep_time}秒")    return return_valueasync def sub_task2():    """子任务2：独立任务"""    return_value = 200    sleep_time = 5    await asyncio.sleep(sleep_time)    print(f"子任务2完成，返回值: {return_value}, 耗时: {sleep_time}秒")    return return_valueasync def main_function():    """主函数：并发执行子任务"""    start_time = time.time()    # 并发执行两个子任务    results = await asyncio.gather(sub_task1(), sub_task2())    end_time = time.time()    total_time = end_time - start_time    print(f"主函数结果: {results}, 总耗时: {total_time:.3f}秒")if __name__ == '__main__':    asyncio.run(main_function())

输出结果：

子任务1完成，返回值: 100, 耗时: 3秒子任务2完成，返回值: 200, 耗时: 5秒主函数结果: [100, 200], 总耗时: 5.003秒

注意：虽然两个任务并发执行，但总耗时接近耗时最长的任务（5秒），而不是两个任务耗时的总和（8秒）。

1.5 复杂await链示例

import asyncioimport timeasync def async_worker():    """一个包含长时间I/O的异步工作者"""    sleep_time = 8    print(f"异步工作者开始，需要执行大约{sleep_time}秒")    await asyncio.sleep(sleep_time)    return 300async def sub_task1():    """子任务1：等待异步工作者的结果"""    result = await async_worker()  # 这里会等待async_worker完成    sleep_time = 3    await asyncio.sleep(sleep_time)    print(f"子任务1完成，返回值: {result}, 额外耗时: {sleep_time}秒")    return resultasync def sub_task2():    """子任务2：独立执行"""    return_value = 200    sleep_time = 5    await asyncio.sleep(sleep_time)    print(f"子任务2完成，返回值: {return_value}, 耗时: {sleep_time}秒")    return return_valueasync def main_function():    """主函数：演示复杂的并发场景"""    start_time = time.time()    # 并发执行两个子任务    results = await asyncio.gather(sub_task1(), sub_task2())    end_time = time.time()    total_time = end_time - start_time    print(f"所有任务结果: {results}, 总耗时: {total_time:.3f}秒")if __name__ == '__main__':    asyncio.run(main_function())

输出结果：

异步工作者开始，需要执行大约8秒子任务2完成，返回值: 200, 耗时: 5秒子任务1完成，返回值: 300, 额外耗时: 3秒所有任务结果: [300, 200], 总耗时: 11.026秒

关键理解：当await后面是一个协程函数时，会先执行该协程直到遇到它内部的await。如果await后面是Future对象，则会立即挂起当前任务，切换到其他任务执行。

二、Future对象：异步编程的底层基石

2.1 Future对象的本质与定义

Future是异步编程中表示"未来某个时刻会完成的异步操作"的容器对象。它是事件循环和**异步执行单元（线程/协程）**之间的通信桥梁，用于存储异步操作的最终结果（返回值或异常）。

2.2 Future解决的核心问题

在同步编程中，阻塞I/O操作（如网络请求、文件读写）会导致整个程序暂停等待。而在异步事件循环模型中，任何阻塞操作都会卡死整个事件循环，导致所有任务都无法执行。

Future的核心价值就是：让阻塞I/O在后台执行，事件循环可以继续调度其他任务，实现真正的并发。

2.3 Future的完整执行流程

假设事件循环同时管理task1（网络I/O任务）和task2（文件I/O任务），执行过程如下：

  1. 触发阻塞I/O，创建后台线程 事件循环执行task1 → 网络接收数据时，检测到这是一个需要等待的阻塞操作。为了不阻塞事件循环，创建一个独立的新线程，将阻塞任务交给新线程执行。

  2. 创建Future对象，建立双向通信 同时创建一个Future对象，事件循环和新线程同时持有这个Future对象：

    • 新线程：负责执行阻塞I/O，完成后将结果写入Future
    • 事件循环：负责监听Future的状态变化

  3. 任务挂起，切换执行其他任务 由于task1需要等待网络I/O结果，事件循环将task1挂起，切换到task2执行，避免在task1上空等。

  4. Future结果就绪，恢复原任务 当新线程完成网络数据接收后，将数据写入Future对象。事件循环检测到Future状态变为"已完成"，会重新调度task1继续执行，并将Future中存储的结果传递给task1。

2.4 Future对象的核心特性

  • 状态可监听
    ：Future有3种核心状态：Pending（等待中）、Finished（已完成）、Cancelled（已取消），事件循环可以轮询或通过回调监听状态变化。
  • 结果可传递
    ：异步操作的返回值、抛出的异常都会被封装在Future中，原任务恢复执行时可以直接获取。
  • 双向通信
    ：既可以让后台线程向事件循环传递结果，也可以让事件循环向后台线程发送取消指令。

2.5 适用场景与扩展说明

  • 图片中的场景是用线程池处理阻塞I/O（Python中concurrent.futures.ThreadPoolExecutor配合asyncio的典型用法），适用于无法被asyncio原生支持的阻塞库（如旧版requests、同步数据库驱动）。
  • 在纯asyncio协程编程中，Future是async/await语法的底层实现：await一个协程本质上就是等待它对应的Future对象完成。
  • Python中asyncio.Future和concurrent.futures.Future是两个不同但功能相似的类，前者用于asyncio事件循环，后者用于线程池/进程池，两者可以通过asyncio.wrap_future()互相转换。

2.6 关键误区澄清

Future本身不执行任何任务，它只是一个"结果容器"和"状态标记"。真正执行异步操作的是后台线程（或协程），Future只负责在不同执行单元之间传递结果和状态。

三、实战示例：Future与线程池的配合使用

下面是一个完整的示例，展示如何使用Future对象配合线程池执行阻塞操作：

import asyncioimport timefrom concurrent.futures import ThreadPoolExecutordef blocking_io_task():    """模拟一个阻塞的I/O操作（如网络请求、文件读写）"""    print("线程池任务开始执行...")    time.sleep(3)  # 模拟3秒阻塞操作    print("线程池任务执行完成")    return 100  # 返回结果async def async_task_with_future():    """异步函数：使用Future处理阻塞操作"""    sleep_time = 8    print(f"异步函数开始执行，内部有{sleep_time}秒非阻塞等待")    # 获取当前事件循环    event_loop = asyncio.get_running_loop()    # 创建线程池执行器    executor = ThreadPoolExecutor(max_workers=1)    # 将阻塞任务提交到线程池，返回Future对象    future = event_loop.run_in_executor(executor, blocking_io_task)    # 异步等待（非阻塞）    await asyncio.sleep(sleep_time)    # 等待线程池任务完成    result = await future    # 关闭线程池    executor.shutdown(wait=True)    return resultdef normal_task():    """普通函数对比"""    print("这是一个普通函数，直接调用执行")async def sub_task1():    """子任务1：演示Future的等待机制"""    # 一般情况下，await后面是协程函数时，会先执行该协程    # 但如果是Future对象，会立即挂起当前任务    result = await async_task_with_future()    sleep_time = 3    await asyncio.sleep(sleep_time)    print(f"子任务1完成，从Future获得结果: {result}, 额外耗时: {sleep_time}秒")    return resultasync def sub_task2():    """子任务2：独立异步任务"""    return_value = 200
本文来自网友投稿或网络内容，如有侵犯您的权益请联系我们删除，联系邮箱：596563534@qq.com 。

python超全入指南这不就来了!

Python其实真的不难,来来回回也就这点东西

最新文章

随机文章