当前位置：首页 > news >正文

python中，asyncio.create_task和await的区别与联系

news 2026/5/1 17:48:54

这是 Python 异步编程 (asyncio) 最核心的两个概念，它们不是对立关系，而是配合使用的关系，一个负责启动并发任务，一个负责等待任务完成。

我用最通俗、最清晰的方式给你讲透：

一、核心一句话总结

await：等待一个异步操作完成，阻塞当前协程，直到结果返回（不主动创建并发）。
asyncio.create_task()：将协程包装成任务并扔进事件循环，立刻后台运行（真正实现并发）。

联系：create_task 创建任务后，最终必须用 await 来等待任务执行完毕、获取结果。

二、详细对比

1. 作用不同

await 异步函数 ()
- 只是调用并等待一个异步函数
- 不会并发，执行完一个才会执行下一个
- 类似同步的函数调用
asyncio.create_task (异步函数 ())
- 把协程变成任务，立刻调度执行
- 不会阻塞当前流程，任务在后台跑
- 这才是实现多任务并发的关键

2. 执行效果不同（最直观）

假设有两个耗时 1 秒的任务：

只用 await：总耗时 2 秒（串行）
先用 create_task，再 await：总耗时 1 秒（并行）

3. 执行时机不同

await 异步函数：调用时才开始执行
create_task：调用后立刻在后台执行

三、代码示例（一看就懂）

示例 1：只用 await（串行，无并发）

import asyncio
import timeasync def task(name, delay):await asyncio.sleep(delay)print(f"任务 {name} 完成")async def main():start = time.time()# 直接 await，串行执行，一个做完再做下一个await task("A", 1)await task("B", 1)print(f"总耗时：{time.time() - start:.2f}s")asyncio.run(main())

任务 A 完成
任务 B 完成
总耗时：2.01s

示例 2：用 create_task + await（并发）

import asyncio
import timeasync def task(name, delay):await asyncio.sleep(delay)print(f"任务 {name} 完成")async def main():start = time.time()# 创建任务，立刻后台运行t1 = asyncio.create_task(task("A", 1))t2 = asyncio.create_task(task("B", 1))# 等待两个任务都执行完毕await t1await t2print(f"总耗时：{time.time() - start:.2f}s")asyncio.run(main())

任务 A 完成
任务 B 完成
总耗时：1.01s

四、关键联系（必须掌握）

create_task 必须配合 await 使用
- create_task 只是启动任务
- 如果不 await 任务，程序可能直接结束，任务来不及执行完
await 可以等待两种对象
- 协程对象：await func()
- 任务对象：await task
真正的并发 = create_task + await
- 只 await：串行
- 只 create_task，不 await：任务可能不执行完
- create_task + await：并发执行 + 等待完成

五、分析本质原理（必须掌握）

以上第一段await串行的代码之所以会表现出串行执行（总耗时约3秒），其本质原理在于 await 关键字的“阻塞”特性 以及 事件循环（Event Loop）的调度机制。

简单来说，await 告诉事件循环：“在这个任务完成之前，请不要执行我（main 协程）后面的任何代码。”

以下是结合 asyncio 底层机制的深度分析：

1. `await` 的本质：控制权交还 + 暂停当前协程

当你写下 await task("A", 2) 时，发生了以下一系列动作：

调用协程：task("A", 2) 被调用，生成一个协程对象。
开始执行：main 协程开始执行 task A 的代码。
遇到挂起点：执行流进入 task A 内部，遇到了 await asyncio.sleep(delay)。
交出控制权：await 使得 task A 暂停，并将控制权交还给事件循环。此时，事件循环知道“task A 需要等待 2 秒”。
关键点：因为 main 协程是在 await task("A", 2) 这一行暂停的，所以 main 协程的状态被“冻结”在这一行。事件循环虽然拿回了控制权，但它无法越过这行代码去执行 main 函数里的下一行（即 await task("B", 1)）。

结论：await 实际上是把当前协程（main）挂起，直到被等待的对象（task A）彻底结束。

2. 事件循环的“单线程”调度逻辑

asyncio 运行在单线程上。事件循环就像一个不知疲倦的调度员，它的工作逻辑非常单纯：

循环检查：查看当前有哪些任务是“就绪”的。
执行任务：运行一个任务，直到它遇到 await 并暂停，或者运行结束。
切换：如果有其他任务就绪，就切换过去；如果没有，就等待 I/O 事件。

在你提供的代码中，执行流程如下表所示：

时间 (秒)	事件循环正在做什么	`main`协程的状态	`task A`的状态	`task B`的状态
0.0	启动 `main`	运行中	未创建	未创建
0.0	`main` 调用 `task A`	暂停 (在 await A 处)	运行中	未创建
0.0	`task A` 遇到 `sleep(2)`	暂停	暂停 (等待2秒)	未创建
0.0-2.0	事件循环发现无事可做，等待 2秒	暂停	暂停	未创建
2.0	`task A` 唤醒，打印结束	暂停	结束	未创建
2.0	`task A` 完成，`main` 恢复	运行中 (继续向下)	已结束	未创建
2.0	`main` 调用 `task B`	暂停 (在 await B 处)	已结束	运行中
2.0	`task B` 遇到 `sleep(1)`	暂停	已结束	暂停 (等待1秒)
2.0-3.0	事件循环等待 1秒	暂停	已结束	暂停
3.0	`task B` 唤醒，打印结束	暂停	已结束	结束
3.0	`task B` 完成，`main` 结束	结束	已结束	已结束

3. 为什么没有并发？

并发的核心在于 “在等待 A 的时候去执行 B”。

在你的代码中，task B 甚至还没有被创建（代码还没运行到那一行），因为 main 协程被死死地卡在 await task("A", 2) 这一行。

串行模式 (await 直接调用)：
main 就像一个只会听指令的机器人，它必须等 A 做完，才敢迈出下一步去叫 B。

T_{t o t a l} = T_{A} + T_{B} = 2 + 1 = 3

并发模式 (create_task)：
如果使用 create_task，相当于 main 告诉事件循环：“把 A 和 B 都安排上”，然后 main 自己去睡觉（await 等待两者完成）。此时 A 和 B 都在事件循环的待办列表中，事件循环可以在 A 睡觉的时候去运行 B。