程序由一个个任务组成,例如读取文件、请求模型、查询数据库和计算结果。理解同步与异步,关键不是看代码有没有多个函数,而是看调用方在等待结果时能不能处理其他工作。
同步(synchronous)表示调用方发起一个操作后,要等这个操作完成并返回结果,才能继续执行下一步:
01import time 02 03def fetch(name): 04 print(f"{name}:开始请求") 05 time.sleep(2) 06 print(f"{name}:请求完成") 07 return f"{name} 的结果" 08 09first = fetch("任务一") 10second = fetch("任务二") 11 12print(first) 13print(second)
执行过程是:
fetch("任务一")
first
fetch("任务二")
second
两个任务各等待 2 秒,总耗时大约是 4 秒。这种执行方式也叫串行:上一个任务没有结束,下一个任务就不会开始。
示例中的 time.sleep() 会阻塞当前线程。严格来说,「同步」描述的是调用方如何取得结果,「阻塞」描述的是等待期间当前线程是否还能执行其他工作。它们不是完全相同的概念,不过在这种常见的同步调用中,两者通常同时出现。
time.sleep()
同步并不是落后的写法。任务之间存在先后依赖、程序规模很小,或者底层库只提供同步 API 时,同步代码通常更直接,也更容易调试。
异步(asynchronous)表示任务等待结果时可以暂停,把执行权交还给调度器。调度器可以利用这段等待时间运行其他已经就绪的任务,结果准备好后再恢复原来的任务。
Python 主要通过标准库 asyncio 提供这种能力:
asyncio
01import asyncio 02 03async def fetch(name): 04 print(f"{name}:开始请求") 05 await asyncio.sleep(2) 06 print(f"{name}:请求完成") 07 return f"{name} 的结果" 08 09async def main(): 10 result = await fetch("任务一") 11 print(result) 12 13asyncio.run(main())
这里出现了三个重要语法:
async def
await
asyncio.run()
执行到 await asyncio.sleep(2) 时,fetch() 暂时不能继续,但它不会像 time.sleep(2) 那样占住事件循环。事件循环可以去运行其他已经准备好的任务。两秒后,fetch() 获得继续执行的资格,再从 await 后面恢复。
await asyncio.sleep(2)
fetch()
time.sleep(2)
异步也不是「把函数扔到后台就不管了」。调用方最终仍然要通过 await 等方式取得结果、处理异常和取消任务。异步改变的是等待方式,不会改变业务上的依赖关系。
如果你熟悉 JavaScript,可以通过下面的表格建立初步对应关系:
async function
Promise
Promise.all()
asyncio.gather()
TaskGroup
setTimeout()
asyncio.sleep()
sleep()
setTimeout(callback)
loop.call_later()
Promise.then()
queueMicrotask()
这张表只用于帮助迁移已有认知,不能把两套运行时机械地画等号。尤其是 JavaScript 调用 async function 会返回 Promise,而 Python 调用 async def 函数只会创建协程对象;协程还需要被 await 或包装成 Task,才会真正开始执行。
JavaScript 通常用「宏任务、微任务」解释回调顺序,asyncio 则更适合用「协程、Task、Future、就绪队列、IO 事件和定时任务」理解。后面的「事件循环」文章会继续展开这些概念。
并发(concurrency)表示一段时间内有多个任务都在推进。它强调的是任务之间可以交替执行,而不是一定要在同一时刻运行。
只把函数写成 async def,不会自动产生并发。下面虽然使用了异步语法,两个任务仍然是串行的:
01import asyncio 02import time 03 04async def fetch(name): 05 print(f"{name}:开始") 06 await asyncio.sleep(2) 07 print(f"{name}:完成") 08 09async def main(): 10 started_at = time.perf_counter() 11 12 await fetch("任务一") 13 await fetch("任务二") 14 15 elapsed = time.perf_counter() - started_at 16 print(f"耗时约 {elapsed:.1f} 秒") 17 18asyncio.run(main())
第一个 await fetch(...) 完成后,程序才会执行第二个调用,因此总耗时仍然接近 4 秒。await 表示等待,不表示自动同时启动后面的任务。
await fetch(...)
要形成并发,需要让多个协程在同一段时间内都进入事件循环。可以使用 asyncio.gather():
01import asyncio 02import time 03 04async def fetch(name): 05 print(f"{name}:开始") 06 await asyncio.sleep(2) 07 print(f"{name}:完成") 08 return name 09 10async def main(): 11 started_at = time.perf_counter() 12 13 results = await asyncio.gather( 14 fetch("任务一"), 15 fetch("任务二"), 16 ) 17 18 elapsed = time.perf_counter() - started_at 19 print(results) 20 print(f"耗时约 {elapsed:.1f} 秒") 21 22asyncio.run(main())
任务一执行到 await 后暂停,事件循环开始运行任务二;任务二也进入等待后,事件循环继续监听它们。大约两秒后,两个任务先后恢复并完成,所以总耗时接近 2 秒。
因此,「异步」和「并发」不是同义词:异步提供可暂停、可恢复的等待方式,并发则是利用这种能力,让多个任务在同一段时间内推进。
并发也不只属于 asyncio。多线程、多进程和分布式服务同样可以让多个任务在一段时间内推进;asyncio 只是 Python 处理大量 IO 等待时的一种高效并发方式。
并行(parallelism)表示多个任务在同一时刻真正执行,通常需要多个 CPU 核心、多个进程,或者能够并行工作的底层程序。
同步、异步、并发和并行描述的不是同一个维度:
单线程事件循环可以实现并发,但不能让两段纯 Python 代码在同一个线程上并行执行:
01import asyncio 02 03async def calculate(): 04 total = 0 05 for number in range(20_000_000): 06 total += number 07 return total 08 09async def main(): 10 await asyncio.gather(calculate(), calculate()) 11 12asyncio.run(main())
calculate() 内部没有 await。第一个任务开始计算后不会主动让出执行权,第二个任务只能等待,因此使用 gather() 也不会使计算变快,反而可能阻塞整个事件循环。
calculate()
gather()
真正需要并行执行 CPU 密集型任务时,通常会使用多个进程、任务队列或独立的计算服务。线程是否能够提升 CPU 计算效率,还会受到 Python 实现和 GIL 等因素影响,后面的「线程」文章会专门说明。
asyncio 的优势来自「等待期间还有其他工作可以做」,因此最适合 IO 密集型任务:
CPU 密集型任务则会持续使用处理器,例如:
可以用下面的判断方式选择执行模型:
asyncio.to_thread()
异步并不一定比同步更快。只有当程序存在可重叠的等待时间时,并发执行才能提高整体吞吐量。单个异步请求的耗时通常不会凭空缩短,改进的是等待期间处理其他请求的能力。
在 FastAPI 服务中,服务器已经创建并维护事件循环:
01import asyncio 02from fastapi import FastAPI 03 04app = FastAPI() 05 06async def call_model(): 07 await asyncio.sleep(1) # 模拟等待模型服务 08 return "模型回复" 09 10@app.get("/chat") 11async def chat(): 12 result = await call_model() 13 return {"result": result}
当 call_model() 等待模型响应时,同一个 worker 可以继续处理其他请求。这里不会因为 100 个请求就默认创建 100 个线程,多个请求通常表现为由事件循环调度的多个协程。
call_model()
不过,只有底层调用本身支持异步,这种写法才有意义。如果在 async def 接口中调用同步 HTTP 客户端或执行耗时计算,它仍然会阻塞事件循环。
还要避免在 FastAPI 接口中调用 asyncio.run()。服务器已经有正在运行的事件循环,接口只需要使用 await。LangChain 的 ainvoke()、astream() 等异步方法也可以按照这种方式接入。
ainvoke()
astream()
用真实的异步定时等待比较连续 await 与 gather。这里没有发送网络请求,等待时间用 sleep 表达。
入口和主题代码与工作区直接共用同一份来源:
01from fastapi import FastAPI, Query 02 03from async_overview import run_experiment 04 05app = FastAPI(title="同步与异步") 06 07@app.get("/async-overview") 08async def experiment( 09 count: int = Query(default=3, ge=1, le=8), 10 delay_ms: int = Query(default=40, ge=5, le=100), 11) -> dict[str, object]: 12 report = await run_experiment(count, delay_ms) 13 print(report) 14 return report 15
01import asyncio 02from time import perf_counter 03 04async def run_experiment(count: int, delay_ms: int) -> dict[str, object]: 05 async def measure(concurrent: bool) -> dict[str, object]: 06 events = [] 07 08 async def fetch(index: int) -> int: 09 events.append(f"{index} 开始") 10 await asyncio.sleep(delay_ms / 1000) 11 events.append(f"{index} 完成") 12 return index 13 14 started = perf_counter() 15 if concurrent: 16 results = await asyncio.gather(*(fetch(index) for index in range(count))) 17 else: 18 results = [] 19 for index in range(count): 20 results.append(await fetch(index)) 21 return {"results": results, "events": events, "elapsed_ms": round((perf_counter() - started) * 1000, 2)} 22 23 return {"serial": await measure(False), "concurrent": await measure(True)} 24
打开在线案例,点击运行,等待环境就绪,再发送默认 GET /async-overview?count=3&delay_ms=40。本篇无需密钥或外部服务。
GET /async-overview?count=3&delay_ms=40
两组 results 都为 [0, 1, 2]。串行组先完成 0 再开始 1;并发组通常先记录三个开始,再逐个记录完成。elapsed_ms 是实际测量值,串行约 120 毫秒,并发约 40 毫秒,浏览器调度会带来偏差。
results
[0, 1, 2]
elapsed_ms
把 count 改为 1 时,两种方式没有可重叠的多项等待;改变 delay_ms 可以观察等待对耗时的影响。数量最多 8,等待最多 100 毫秒,不执行文章里大型 CPU 循环。
count
delay_ms
实验事件和状态每次请求独立创建。实际定时与耗时会受到运行环境影响,不能据此承诺固定调度顺序或实时精度。日志输出本次报告,可以在修改参数后对照查看。
下载项目后,在本机终端执行:
1uv run fastapi dev main.py
然后通过 http://127.0.0.1:8000/docs 发送同一请求。文章中的 asyncio.run(...) 是独立终端脚本入口;浏览器和 FastAPI 接口已经有事件循环,这里的案例直接 await 实验函数。
http://127.0.0.1:8000/docs
asyncio.run(...)
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 同步
程序由一个个任务组成,例如读取文件、请求模型、查询数据库和计算结果。理解同步与异步,关键不是看代码有没有多个函数,而是看调用方在等待结果时能不能处理其他工作。
同步(synchronous)表示调用方发起一个操作后,要等这个操作完成并返回结果,才能继续执行下一步:
执行过程是:
fetch("任务一");first;fetch("任务二");second。两个任务各等待 2 秒,总耗时大约是 4 秒。这种执行方式也叫串行:上一个任务没有结束,下一个任务就不会开始。
示例中的
time.sleep()会阻塞当前线程。严格来说,「同步」描述的是调用方如何取得结果,「阻塞」描述的是等待期间当前线程是否还能执行其他工作。它们不是完全相同的概念,不过在这种常见的同步调用中,两者通常同时出现。同步并不是落后的写法。任务之间存在先后依赖、程序规模很小,或者底层库只提供同步 API 时,同步代码通常更直接,也更容易调试。
2. 异步
异步(asynchronous)表示任务等待结果时可以暂停,把执行权交还给调度器。调度器可以利用这段等待时间运行其他已经就绪的任务,结果准备好后再恢复原来的任务。
Python 主要通过标准库
asyncio提供这种能力:这里出现了三个重要语法:
async def定义协程函数;await等待异步操作,并允许当前协程暂停;asyncio.run()创建并管理事件循环,运行入口协程。执行到
await asyncio.sleep(2)时,fetch()暂时不能继续,但它不会像time.sleep(2)那样占住事件循环。事件循环可以去运行其他已经准备好的任务。两秒后,fetch()获得继续执行的资格,再从await后面恢复。异步也不是「把函数扔到后台就不管了」。调用方最终仍然要通过
await等方式取得结果、处理异常和取消任务。异步改变的是等待方式,不会改变业务上的依赖关系。如果你熟悉 JavaScript,可以通过下面的表格建立初步对应关系:
asyncioasyncio事件循环async functionasync defawaitawaitPromisePromise.all()asyncio.gather()、TaskGroupsetTimeout()asyncio.sleep()sleep()暂停协程,不接收回调函数setTimeout(callback)loop.call_later()Promise.then()、queueMicrotask()asyncio使用自己的就绪队列、Task 和 Future 调度模型这张表只用于帮助迁移已有认知,不能把两套运行时机械地画等号。尤其是 JavaScript 调用
async function会返回 Promise,而 Python 调用async def函数只会创建协程对象;协程还需要被await或包装成 Task,才会真正开始执行。JavaScript 通常用「宏任务、微任务」解释回调顺序,
asyncio则更适合用「协程、Task、Future、就绪队列、IO 事件和定时任务」理解。后面的「事件循环」文章会继续展开这些概念。3. 并发
并发(concurrency)表示一段时间内有多个任务都在推进。它强调的是任务之间可以交替执行,而不是一定要在同一时刻运行。
只把函数写成
async def,不会自动产生并发。下面虽然使用了异步语法,两个任务仍然是串行的:第一个
await fetch(...)完成后,程序才会执行第二个调用,因此总耗时仍然接近 4 秒。await表示等待,不表示自动同时启动后面的任务。要形成并发,需要让多个协程在同一段时间内都进入事件循环。可以使用
asyncio.gather():任务一执行到
await后暂停,事件循环开始运行任务二;任务二也进入等待后,事件循环继续监听它们。大约两秒后,两个任务先后恢复并完成,所以总耗时接近 2 秒。因此,「异步」和「并发」不是同义词:异步提供可暂停、可恢复的等待方式,并发则是利用这种能力,让多个任务在同一段时间内推进。
并发也不只属于
asyncio。多线程、多进程和分布式服务同样可以让多个任务在一段时间内推进;asyncio只是 Python 处理大量 IO 等待时的一种高效并发方式。4. 并行
并行(parallelism)表示多个任务在同一时刻真正执行,通常需要多个 CPU 核心、多个进程,或者能够并行工作的底层程序。
同步、异步、并发和并行描述的不是同一个维度:
await处暂停,稍后恢复单线程事件循环可以实现并发,但不能让两段纯 Python 代码在同一个线程上并行执行:
calculate()内部没有await。第一个任务开始计算后不会主动让出执行权,第二个任务只能等待,因此使用gather()也不会使计算变快,反而可能阻塞整个事件循环。真正需要并行执行 CPU 密集型任务时,通常会使用多个进程、任务队列或独立的计算服务。线程是否能够提升 CPU 计算效率,还会受到 Python 实现和 GIL 等因素影响,后面的「线程」文章会专门说明。
5. 场景
asyncio的优势来自「等待期间还有其他工作可以做」,因此最适合 IO 密集型任务:CPU 密集型任务则会持续使用处理器,例如:
可以用下面的判断方式选择执行模型:
asyncio并发asyncio.to_thread()异步并不一定比同步更快。只有当程序存在可重叠的等待时间时,并发执行才能提高整体吞吐量。单个异步请求的耗时通常不会凭空缩短,改进的是等待期间处理其他请求的能力。
6. 服务
在 FastAPI 服务中,服务器已经创建并维护事件循环:
当
call_model()等待模型响应时,同一个 worker 可以继续处理其他请求。这里不会因为 100 个请求就默认创建 100 个线程,多个请求通常表现为由事件循环调度的多个协程。不过,只有底层调用本身支持异步,这种写法才有意义。如果在
async def接口中调用同步 HTTP 客户端或执行耗时计算,它仍然会阻塞事件循环。还要避免在 FastAPI 接口中调用
asyncio.run()。服务器已经有正在运行的事件循环,接口只需要使用await。LangChain 的ainvoke()、astream()等异步方法也可以按照这种方式接入。7. 在线实验
用真实的异步定时等待比较连续 await 与 gather。这里没有发送网络请求,等待时间用 sleep 表达。
入口和主题代码与工作区直接共用同一份来源:
打开在线案例,点击运行,等待环境就绪,再发送默认
GET /async-overview?count=3&delay_ms=40。本篇无需密钥或外部服务。两组
results都为[0, 1, 2]。串行组先完成 0 再开始 1;并发组通常先记录三个开始,再逐个记录完成。elapsed_ms是实际测量值,串行约 120 毫秒,并发约 40 毫秒,浏览器调度会带来偏差。把
count改为 1 时,两种方式没有可重叠的多项等待;改变delay_ms可以观察等待对耗时的影响。数量最多 8,等待最多 100 毫秒,不执行文章里大型 CPU 循环。实验事件和状态每次请求独立创建。实际定时与耗时会受到运行环境影响,不能据此承诺固定调度顺序或实时精度。日志输出本次报告,可以在修改参数后对照查看。
下载项目后,在本机终端执行:
然后通过
http://127.0.0.1:8000/docs发送同一请求。文章中的asyncio.run(...)是独立终端脚本入口;浏览器和 FastAPI 接口已经有事件循环,这里的案例直接await实验函数。