04.7.4 迭代器、生成器与 async 协程
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python
覆盖范围
- 可迭代对象与迭代器协议、
for的执行机制 - 生成器函数、
yield、yield from、send/throw/close - 惰性求值、生成器管道与资源释放
async def、await、事件循环与 Task/Future- 异步上下文管理器、异步迭代、超时与取消
- 协程与线程的对比及常见反模式
04.7.4-001 可迭代对象和迭代器有什么区别?
一句话结论
可迭代对象实现 __iter__,每次调用返回一个新的迭代器;迭代器同时实现 __iter__(返回自身)和 __next__(产出下一个值或抛 StopIteration)。list、dict、str 是可迭代对象但不是迭代器;生成器、iter(list) 是迭代器。
概念解释
- 可迭代对象可被多次遍历(每次
iter()得到新游标);迭代器一次性,游标在对象内部。 - 判断用
collections.abc.Iterable/Iterator,或iter()尝试 + TypeError。
原理流程
iter(obj)对可迭代对象调用__iter__;对序列若没有__iter__会退回__getitem__+ 下标协议(老式协议)。- 迭代器实现
__next__推进游标,耗尽时抛StopIteration。 - 迭代器必须自己返回自己:
iter(it) is it;next(it, default)可在耗尽时返回默认值而不抛异常。
代码或图示
nums = [1, 2, 3] # 可迭代对象
it = iter(nums) # 迭代器
print(next(it), next(it)) # 1 2
print(iter(nums) is it) # False,每次新游标
常见误区
- 把可迭代对象当迭代器复用:list 遍历两次都有数据,是因为每次
for都创建新迭代器。 - 生成器遍历一次就空:生成器对象本身就是迭代器,游标只前进不复位;
iter()对非可迭代对象会抛 TypeError: not iterable。
追问
- 为什么 list 遍历两次都有数据?答:每次
for都调用iter(list)创建新迭代器。 - 生成器为什么遍历一次就空?答:生成器对象本身就是迭代器,游标只前进不复位。
iter()对非可迭代对象会怎样?答:抛 TypeError: not iterable。
04.7.4-002 for 循环内部是怎么执行的?
一句话结论
for x in obj: 先调 iter(obj) 取迭代器,然后循环调用 next(it) 取下一个值;每次迭代把值绑定给 x,直到 next 抛 StopIteration 时静默结束(异常被 for 吞掉),其他异常继续传播。
概念解释
continue跳到下一次next。- 循环的
else只在“正常耗尽”时执行,break跳出不执行。
原理流程
for先对目标对象调用iter()取得迭代器。- 每轮调用
next(it),把返回值绑定给循环变量。 - 收到
StopIteration即结束循环;其他异常继续向外传播。
代码或图示
it = iter([1, 2, 3])
while True:
try:
x = next(it)
except StopIteration:
break
print(x)
常见误区
break直接退出循环,不调用迭代器收尾;需要清理时用with或显式close()。for不会复制容器,遍历时修改容器可能导致跳过或 RuntimeError;生成器在break后可能延迟到 GC 才关闭。
追问
- 循环
else有什么用?答:表达“没被 break 打断”,如查找失败分支。 - 为什么遍历中删除元素会漏?答:删除导致后续元素前移,而迭代器下标继续前进。
break后生成器会立刻关闭吗?答:不一定,引用消失后由 GC 关闭,最好显式close()或用with。
04.7.4-003 迭代器为什么只能遍历一次?如何复用?
一句话结论
迭代器把遍历状态存在自己内部(游标/索引),__next__ 只前进不复位;耗尽后再 next 永远 StopIteration。要复用需重新创建迭代器(再次 iter(可迭代对象)),或把结果物化成 list。
概念解释
- 需要多次遍历时:用列表/元组缓存、用可重复迭代的自定义容器、或每次重新生成。
- 传参给多个消费者时,明确“谁负责消费”,避免被上游悄悄耗尽。
原理流程
- 迭代器内部保存当前游标,
__next__只向前推进。 - 耗尽后游标到达末尾,后续
next直接抛StopIteration。 - 重新
iter(可迭代对象)才会得到带新游标的迭代器。
代码或图示
it = (x for x in range(3))
print(list(it)) # [0, 1, 2]
print(list(it)) # []
常见误区
zip/map/filter/reversed/enumerate在 Python 3 都返回迭代器,二次遍历会得到空。itertools.tee可把一个迭代器分成多个(内部缓冲),但会占内存且不适合无限流;调试时打印迭代器只看到<generator object>,需要list(islice(it, 5))观察前几项。
追问
tee为什么可能爆内存?答:它缓存“跑得慢的那一路”还没消费的元素。- 为什么函数返回迭代器要小心?答:调用方遍历一次后数据就没了,需在文档中声明。
range能多次遍历吗?答:能,它是可迭代对象,每次iter返回新range_iterator。
04.7.4-004 生成器函数是怎么执行的?yield 做了什么?
一句话结论
调用生成器函数不会执行函数体,只返回生成器对象;每次 next() 从上次暂停处继续执行到下一个 yield,把值交回调用方并保存局部变量与执行位置;函数结束时抛 StopIteration(可带返回值)。
概念解释
- 生成器帧保留局部变量、指令指针与异常状态,是“可暂停的函数”。
- 生成器是惰性的:不调用
next就一行都不执行。
原理流程
- 调用生成器函数时只创建生成器对象,函数体不执行。
- 首次
next()从函数开头执行到第一个yield,交出值并暂停。 - 后续
next()/send()从暂停点恢复,保存的局部变量与指令指针继续生效;函数结束抛StopIteration。
代码或图示
def gen():
print("start")
x = yield 1
print("got", x)
yield 2
g = gen() # 什么都不打印
next(g) # start,返回 1
g.send(10) # got 10,返回 2
常见误区
yield是表达式,可以接收send()传回的值;return在生成器中结束迭代,StopIteration.value保存返回值。- 生成器函数中任何
yield的出现都会让整个函数变成生成器,即使分支永远不执行。
追问
- 生成器函数第一次
next执行到哪?答:从函数开头执行到第一个yield。 - 局部变量在暂停期间存在哪?答:存在生成器帧对象里,随生成器存活。
- 生成器的返回值怎么拿?答:捕获
StopIteration.value,或用yield from自动传递。
04.7.4-005 yield from 解决了什么问题?
一句话结论
yield from iterable 把子迭代器的产出全部转发给外层,并自动传递 send() 的值、throw() 的异常与 close(),最后返回子生成器的 return 值。它省掉手写 for x in sub: yield x,也是早期协程委托的基础。
概念解释
- 委托链可多层嵌套,形成“调用栈”。
- 对普通可迭代对象(list)也适用,但没有 send/throw 语义。
原理流程
yield from接管子迭代器,逐个把其产出转发给外层调用方。- 外层
send()/throw()/close()被透传给子生成器。 - 子生成器结束后,其
return值作为yield from表达式结果。
代码或图示
def inner():
yield 1
yield 2
return "done"
def outer():
r = yield from inner()
print("inner return:", r)
yield 3
常见误区
- 对无限生成器用
yield from:外层永远停在里面,后面的代码不会执行。 - 3.3+ 引入,是
async/await的前身(await语义类似yield from);异常透传时子生成器抛 StopIteration 由yield from捕获并作为表达式结果。
追问
yield from和for + yield的区别?答:前者透传 send/throw/close 并返回子生成器结果,后者只转发产出。- 为什么它能简化协程?答:它把“暂停/恢复/异常”委托给子协程,避免手写状态机。
- 对无限生成器用
yield from会怎样?答:外层永远停在里面,后面的代码不会执行。
04.7.4-006 生成器的 send、throw、close 分别做什么?
一句话结论
send(v) 恢复执行并把 v 作为当前 yield 表达式的值;throw(type, val, tb) 在暂停点抛入异常,生成器可捕获处理;close() 在暂停点抛 GeneratorExit,用于触发 finally 清理并结束生成器。
概念解释
- 这三个方法是“生成器即协程”的底层基础,asyncio 早期就用它们驱动。
close()后生成器进入关闭状态,再next抛 StopIteration。
原理流程
send(v)把 v 作为当前yield表达式结果,从暂停点恢复。throw(...)在暂停点注入异常,生成器可捕获并继续,否则异常向外传播并结束生成器。close()注入GeneratorExit,触发finally清理后结束生成器。
代码或图示
def worker():
try:
while True:
item = yield
print("handle", item)
finally:
print("cleanup")
g = worker()
next(g)
g.send("a")
g.close() # 触发 finally
常见误区
- 首次必须用
next()或send(None)启动,直接send(非 None)会 TypeError。 - 生成器忽略
GeneratorExit并继续yield会 RuntimeError;throw若生成器不捕获该异常,会向外传播并结束生成器。
追问
- 为什么第一次要
next?答:生成器还没运行到yield,没有接收点。 close()一定执行finally吗?答:会抛 GeneratorExit,finally会执行;但不要在 finally 里再yield。throw常用来做什么?答:向生成器注入错误(如上游数据源失败),让下游统一处理。
04.7.4-007 生成器表达式和列表推导式的选择标准是什么?
一句话结论
看“是否需要多次遍历/长度/索引”和“数据规模”。需要物化结果、重复使用、随机访问用列表推导;只需要流式消费一次、数据量大或无限用生成器表达式。
概念解释
- 生成器不能
len()、不能下标、不能重复遍历。 - 把生成器传给
sum/any/all/max/min是最经济的用法。
原理流程
- 列表推导在求值时把全部元素物化到列表,内存 O(n)。
- 生成器表达式只保留当前元素与迭代状态,内存 O(1)。
- 生成器表达式作为函数唯一参数时可省括号:
sum(x for x in xs)。
代码或图示
total = sum(x * x for x in range(1_000_000)) # 不建中间列表
squares = [x * x for x in range(100)] # 需要复用/索引
常见误区
- 生成器中的异常在消费时才暴露,调试时定位更晚,注意边界。
list(gen)之后内存又上去:物化会把所有元素搬进列表,失去惰性优势;生成器表达式可嵌套,但多层 for 等价于嵌套循环,可读性差。
追问
- 生成器表达式能嵌套吗?答:能,多层 for 等价于嵌套循环,但可读性差。
- 为什么
list(gen)之后内存又上去了?答:物化会把所有元素搬进列表,失去惰性优势。 - 生成器里做 IO 有什么风险?答:异常延迟到消费时抛出,且资源可能未及时关闭。
04.7.4-008 如何用生成器高效读取大文件?
一句话结论
逐行迭代文件对象本身就是流式读取:for line in f: 不会一次性载入整个文件;需要分块处理二进制或定长记录时,用 f.read(chunk) 配合 iter(lambda: f.read(n), b"") 或自写生成器。
概念解释
- 文本模式按行缓冲,内存占用与最长行相关,不是文件大小。
- 逐行处理可用生成器做管道:读 → 解析 → 过滤 → 聚合,每步都惰性。
原理流程
- 文本模式逐行从缓冲读取,只保留当前行。
- 二进制分块循环
read(size),读到空字节结束。 - 生成器把块/行逐个产出,消费端按需处理。
代码或图示
def chunks(path, size=8192):
with open(path, "rb") as f:
while True:
block = f.read(size)
if not block:
return
yield block
def lines(path):
with open(path, encoding="utf-8") as f:
for line in f:
yield line.rstrip("\n")
常见误区
f.read()不带参数会读入全部内容,大文件会 OOM。- 忘记
with open(...)保证异常时关闭;生成器被提前中断时也要能释放;iter(callable, sentinel)是标准的分块写法,直到读到空字节结束。
追问
- 为什么
for line in f比f.readlines()好?答:后者一次性把全部行读进内存。 - 分块大小怎么定?答:常见 4KB~64KB,太小 syscall 多,太大占内存且首块延迟高。
- 生成器里
with的退出时机?答:生成器结束或关闭时,finally/with释放文件句柄。
04.7.4-009 生成器提前中断时资源怎么释放?
一句话结论
生成器在 close()、被 GC 回收、或包裹在 with 中退出时会触发 GeneratorExit,finally 代码得以执行。但依赖 GC 不可靠,应显式 close()、用 contextlib.closing,或把资源管理写在生成器内部的 with 里。
概念解释
- 生成器内部
try/finally是释放资源的正确位置。 - 异步生成器对应
aclose()。
原理流程
- 显式
close()或 GC 回收时,在暂停点抛GeneratorExit。 - 生成器进入
finally执行清理逻辑。 - 生成器互相嵌套时,外层关闭会
close()内层(通过yield from或手动)。
代码或图示
def reader(path):
f = open(path, encoding="utf-8")
try:
for line in f:
yield line
finally:
f.close()
r = reader("big.txt")
next(r)
r.close() # 立即释放句柄
常见误区
for循环break不会自动close()生成器,引用还在就继续挂着。GeneratorExit期间不能yield,否则 RuntimeError;with包生成器调用不能替代内部资源管理,with open(...)退出时生成器还没消费。
追问
- 为什么不
close()会泄漏文件句柄?答:生成器帧仍持有f,直到引用计数归零。 with包生成器调用能解决吗?答:不能,with open(...)退出时生成器还没消费;资源管理要在生成器内部。- GC 一定会调用
close()吗?答:CPython 引用计数归零时会,但循环引用、解释器退出等场景不保证。
04.7.4-010 生成器里的异常如何传播?StopIteration 有什么特殊?
一句话结论
next() 时生成器内部抛出的异常会原样传给调用方并结束生成器;StopIteration 被解释为“迭代正常结束”,但若在生成器内部被显式抛出,会被转成 RuntimeError(PEP 479),避免与“正常结束”混淆。
概念解释
- 外部
throw()注入异常,生成器可捕获并继续yield。 - 生成器内异常若带
finally,会先执行清理再传播。
原理流程
- 生成器内部抛出普通异常,原样传给调用方并结束生成器。
- 生成器内
raise StopIteration被 PEP 479 转成 RuntimeError 向外传播。 - 用
yield from时子生成器的异常会透传到外层。
代码或图示
def g():
yield 1
return # 正确结束
def bad():
yield 1
raise StopIteration # RuntimeError
常见误区
- 需要在生成器内提前结束,用
return而不是raise StopIteration。 - 生成器抛出异常后进入已结束状态,再
next抛 StopIteration;yield from会透传子生成器异常。
追问
- PEP 479 为什么改这个行为?答:生成器内部的 StopIteration 会被
for当成正常结束,静默吞掉真实错误。 - 怎么在生成器里“提前退出”?答:
return,必要时return value供yield from捕获。 - 生成器抛出异常后会怎样?答:生成器进入已结束状态,再
next抛 StopIteration。
04.7.4-011 什么是惰性求值?生成器管道怎么写?
一句话结论
惰性求值指“用到才算”,生成器只在被 next 驱动时执行一步。管道把多个生成器串联,每个环节只处理当前元素,内存恒定、首元素延迟低,适合日志处理、ETL、流式解析。
概念解释
- 每级生成器职责单一:读、解析、过滤、转换、聚合。
- 管道是拉模型(下游
next拉动上游),不是推模型。
原理流程
- 下游对最末级生成器调用
next,逐级向上游拉取元素。 - 每级只处理当前元素后产出给下一级。
- 某一级抛异常会中断整条管道,需在边界做容错。
代码或图示
def read(path):
with open(path, encoding="utf-8") as f:
yield from f
def parse(lines):
for line in lines:
yield line.strip().split(",")
def only_valid(rows):
for r in rows:
if len(r) == 3:
yield r
pipeline = only_valid(parse(read("data.csv")))
for row in pipeline:
...
常见误区
- 管道和列表链式操作不同:管道逐元素流式,列表链式每步物化整个集合。
- 生成器一旦抛出就结束,需要在外层重建管道;调试困难,加日志或用
itertools.islice抽样观察;需要并行时管道不适用,应改用队列/多进程。
追问
- 管道和列表链式操作的区别?答:管道逐元素流式,列表链式每步物化整个集合。
- 为什么管道难做异常恢复?答:生成器一旦抛出就结束,需要在外层重建管道。
- 如何在管道中做批量聚合?答:用
itertools.islice或自定义“攒批”生成器。
04.7.4-012 如何自定义一个可迭代类?
一句话结论
实现 __iter__ 返回迭代器即可;若想同时是迭代器,实现 __iter__(返回 self)与 __next__(推进并返回值或抛 StopIteration)。推荐“容器类只做 __iter__,迭代状态放独立迭代器”,这样可多次遍历。
概念解释
- 实现
__len__可让len()、真值判断可用;实现__contains__可优化in。 - 迭代器最好也实现
__iter__返回 self,符合协议。
原理流程
- 容器类
__iter__里用生成器最简洁:return (x for x in self.data)或yield。 - 独立迭代器实现
__next__自行维护游标,耗尽时抛StopIteration。 - 两者配合实现可重复遍历。
代码或图示
class Countdown:
def __init__(self, n): self.n = n
def __iter__(self):
n = self.n
while n > 0:
yield n
n -= 1
for i in Countdown(3): print(i) # 3 2 1
常见误区
- 容器同时实现
__next__会变成一次性迭代器,第二次遍历为空。 - 大量元素时注意
__next__的 Python 调用开销;__getitem__老式序列协议也能支持遍历,但不如__iter__清晰。
追问
- 为什么用生成器实现
__iter__更好?答:不用手写游标与 StopIteration,状态自动保存。 - 容器同时实现
__next__有什么问题?答:它变成一次性迭代器,第二次遍历为空。 __getitem__也能支持遍历吗?答:能,老式序列协议会用下标递增直到 IndexError,但不如__iter__清晰。
04.7.4-013 无限序列怎么生成和消费?
一句话结论
无限序列用生成器 + itertools.count/repeat/cycle 生成;消费时必须加边界:islice、takewhile、zip 配有限序列、或显式 break,否则会永久阻塞。
概念解释
itertools.count(start, step)无限计数,cycle循环已有序列,repeat重复常量。- 消费端一定要有终止条件,且要考虑超时。
原理流程
- 生成器/itertools 工具持续产出元素,不自行终止。
- 消费端通过
islice取前 n 项、takewhile条件满足时取、或zip配有限序列截断。 - 到达边界后停止驱动生成器。
代码或图示
from itertools import count, islice
print(list(islice(count(10, 5), 3))) # [10, 15, 20]
常见误区
- 无限生成器不能
list()、sum()、len()。 - 下游缓存结果(如 list)会无限增长;
cycle第一轮先遍历原序列,再无限重复,原序列需可重复迭代或已缓存。
追问
- 无限生成器会内存泄漏吗?答:本身不会,但下游缓存结果(如 list)会无限增长。
cycle的第一轮行为?答:先遍历原序列,再无限重复;原序列需可重复迭代或已缓存。- 怎么做“每 100 条批量提交”?答:用
islice分批或自定义攒批生成器。
04.7.4-014 生成器和协程是什么关系?
一句话结论
历史上 Python 用生成器的 send/throw/yield from 实现协程(@coroutine 装饰器 + yield);3.5 起引入 async def/await,把“协程”从生成器中独立出来,语义更清晰、错误更难误用。生成器是可暂停函数,协程是“可等待的并发单元”。
概念解释
- 生成器协程靠
yield暂停、send恢复,需要调度器驱动。 - 异步生成器(
async def+yield)用于流式异步数据。
原理流程
- 早期协程复用生成器暂停/恢复能力,由调度器驱动。
- 原生协程对象是
types.CoroutineType,不能直接next(),只能被事件循环/await驱动。 await只能出现在async def内,避免“忘了驱动”的隐蔽 bug。
代码或图示
async def fetch():
data = await get_data()
return data
常见误区
- 老代码可能用
@asyncio.coroutine,已被 3.11 移除。 - 原生协程没有
__next__,必须通过send(None)或事件循环驱动;await语义上相当于“委托给可等待对象”,底层调度类似yield from。
追问
- 为什么原生协程不能直接
next?答:它没有__next__,必须通过send(None)或事件循环驱动。 yield from与await的对应关系?答:await语义上相当于“委托给可等待对象”,底层调度类似yield from。- 生成器协程还有什么用?答:手写状态机、管道、惰性计算,不用于并发调度。
04.7.4-015 async def 和 await 在底层是怎么工作的?
一句话结论
async def 定义的函数调用后返回协程对象,不执行函数体;await 把控制权交回事件循环,等被等待对象完成后从暂停点恢复。事件循环用 epoll/kqueue/IOCP 监听 IO 就绪,用回调/任务队列恢复协程。
概念解释
- 协程对象有
send/throw/close,类似生成器;await编译成GET_AWAITABLE+YIELD_FROM指令。 - 协程只提供“暂停能力”,真正并发靠事件循环多路复用。
原理流程
- 调用
async def函数只创建协程对象,函数体不执行。 - 遇到
await时,把控制权交回事件循环,协程挂起并登记回调。 - 被等待对象就绪后,回调把协程恢复为可运行,从暂停点继续。
代码或图示
async def main():
print("before")
await asyncio.sleep(1)
print("after")
asyncio.run(main())
常见误区
- 阻塞调用(
time.sleep、同步 DB 驱动)会卡住整个循环,必须放线程池。 await的对象必须实现__await__(返回迭代器)或本身就是协程/Future;协程函数不await会返回协程对象但不执行,伴随 “coroutine was never awaited” 警告。
追问
await会阻塞线程吗?答:不会,它让出控制权给事件循环,线程可去处理其他任务。- 为什么
await必须在async def内?答:语法与调度约束,避免在同步上下文里产生无法驱动的协程。 - 协程函数不
await会怎样?答:返回协程对象但不执行,通常伴随 “coroutine was never awaited” 警告。
04.7.4-016 事件循环是什么?它如何调度多个协程?
一句话结论
事件循环是单线程调度器:维护就绪队列与定时器堆,注册 IO 多路复用监听;每当协程 await 一个未完成的操作就挂起并登记回调,操作就绪后回调把协程恢复为可运行,循环继续推进。
概念解释
- 一个线程一个循环(
asyncio.run会创建新循环);同一时刻只有一个协程在跑。 - 循环不在“并行执行”,而是在 IO 等待期间切换任务,适合 IO 密集。
原理流程
- 每轮处理就绪回调队列,推进可运行任务。
- 计算下次定时器超时,进入 IO 多路复用等待就绪事件。
- 就绪事件触发对应回调,把协程重新排到就绪队列。
代码或图示
import asyncio
async def worker(i):
await asyncio.sleep(0.1)
return i
async def main():
return await asyncio.gather(*(worker(i) for i in range(5)))
print(asyncio.run(main()))
常见误区
- 循环卡住(CPU 密集、同步阻塞)会导致所有任务饥饿。
- 多核要并行需多进程,每进程各自一个循环;
call_soon把回调排到下一轮,call_later用定时器。
追问
- 事件循环能跑 CPU 密集任务吗?答:不能,会独占循环;用
run_in_executor或进程池。 - 为什么
time.sleep会卡住所有协程?答:它阻塞线程,循环无法继续调度。 - 一个进程能有多个循环吗?答:可以但不推荐,
asyncio.run禁止嵌套;跨循环共享对象会报错。
04.7.4-017 协程、Task、Future 有什么区别?
一句话结论
协程是“可等待的计算描述”,不调度就不执行;Future 是“未来结果的占位符”,可被设置结果/异常;Task 是“被事件循环调度的协程”,继承 Future,能取消、能查状态、能加回调。
概念解释
await coro直接在当前协程内联执行,不产生并发。- Future 一般由底层回调(如
loop.create_future())使用,业务代码多用 Task。
原理流程
- 协程对象描述待执行的计算,未被调度前不运行。
asyncio.create_task(coro)把协程排入循环并发执行,包装成 Task。- Task 继承 Future,记录完成状态、结果/异常,并支持取消与回调。
代码或图示
async def main():
t = asyncio.create_task(work())
await asyncio.sleep(0) # 让出,任务开始执行
print(t.done())
await t
常见误区
- 以为
await coro会并发:它在当前协程栈里同步推进,直到协程完成才返回。 - Task 排入循环后若循环提前关闭可能被取消;
task.cancel()在下一个 await 点抛CancelledError;asyncio.gather内部会把协程包装成 Task。
追问
- 为什么
await coro不并发?答:它在当前协程栈里同步推进,直到协程完成才返回。 - Task 被创建后一定执行吗?答:排入循环后会在后续轮次执行,若循环提前关闭可能被取消。
- Future 和 Task 能互相等待吗?答:都能
await,Task 是 Future 的子类。
04.7.4-018 asyncio.run 为什么不能在已有事件循环里调用?
一句话结论
asyncio.run 会创建新循环、运行到完成、最后关闭循环;若当前线程已有运行中的循环,再创建/运行会冲突(RuntimeError: asyncio.run() cannot be called from a running event loop)。Jupyter、某些框架、嵌套调用常触发此问题。
概念解释
- 一个线程同一时刻只能有一个运行中的循环。
- 框架(FastAPI、Jupyter)已托管循环,业务代码只写
async def。
原理流程
asyncio.run入口检查当前线程是否已有运行中的循环。- 无循环时创建新循环、运行协程、结束后取消剩余任务并关闭循环。
- 已有运行循环时直接抛 RuntimeError。
代码或图示
# 错误
async def main():
asyncio.run(other()) # RuntimeError
# 正确
async def main():
await other()
常见误区
- 在协程内需要调用异步函数时直接
await,不要asyncio.run。 - 需要从同步代码调用异步逻辑且已有循环时,用
loop.run_until_complete(同循环内)或放到独立线程;asyncio.run结束时取消未完成任务并关闭异步生成器,适合“程序入口”。
追问
- 在 Jupyter 里怎么跑异步?答:直接
await(内核已托管循环),不要asyncio.run。 - 需要在同步函数里调用协程怎么办?答:顶层用
asyncio.run,或在托管循环中用run_coroutine_threadsafe。 asyncio.run会清理什么?答:取消剩余任务、关闭异步生成器、关闭执行器。
04.7.4-019 在协程里调用同步阻塞函数会发生什么?
一句话结论
会阻塞整个事件循环线程,所有其他协程、定时器、心跳全部停摆,表现为“服务假死”。必须用 asyncio.to_thread()(3.9+)或 loop.run_in_executor() 把阻塞调用丢到线程池,或改用异步驱动库。
概念解释
- 常见阻塞源:
time.sleep、requests、同步 DB 驱动、大文件读写、hashlib大文件摘要、CPU 密集计算。 - 线程池任务不受协程取消影响,取消后线程仍在跑。
原理流程
- 阻塞调用占住事件循环线程,循环无法处理就绪回调与定时器。
- 其他协程全部饥饿,直到阻塞调用返回。
to_thread/run_in_executor把调用交给线程池,循环线程继续调度。
代码或图示
async def handler():
data = await asyncio.to_thread(requests.get, url, timeout=5)
return data.json()
常见误区
- 线程池默认大小有限(
min(32, cpu+4)),大量阻塞任务会排队,需要调大或独立池。 - CPU 密集应使用进程池,避免 GIL 限制;判断方法:看循环
lag、asyncio.debug=True的慢回调日志。
追问
- 为什么
requests不能用?答:它是同步库,会阻塞循环;用httpx.AsyncClient或aiohttp。 to_thread和run_in_executor区别?答:前者是语法糖,后者可指定执行器;都返回可等待对象。- 阻塞调用超时了怎么办?答:用
asyncio.wait_for包一层,但底层线程仍可能继续执行。
04.7.4-020 异步上下文管理器怎么实现?
一句话结论
实现 __aenter__/__aexit__ 并用 async with,或用 @contextlib.asynccontextmanager 写异步生成器(yield 前为进入、后为退出)。用于异步连接、异步锁、异步事务。
概念解释
__aexit__返回值语义与同步版一致:True 吞异常。- 多个资源用
AsyncExitStack管理。
原理流程
- 进入
async with时await __aenter__,返回值绑定给as。 - 退出时
await __aexit__,传入异常三元组。 - 异步生成器版在
yield处挂起,退出时从yield后恢复执行清理。
代码或图示
from contextlib import asynccontextmanager
@asynccontextmanager
async def session():
s = await create_session()
try:
yield s
finally:
await s.close()
常见误区
async with不能用于同步上下文管理器,需手动await其异步版本。- 退出逻辑不要做无限等待,避免关闭阶段卡死;异步生成器版中异常在
yield处抛入,可 try/except/finally。
追问
asynccontextmanager内部是什么?答:把异步生成器包装成实现__aenter__/__aexit__的对象。- 能在
async with里return吗?答:可以,退出逻辑仍会执行。 - 退出时取消会怎样?答:
CancelledError会在yield处抛入,finally需保证清理。
04.7.4-021 异步迭代器和 async for 怎么用?
一句话结论
异步迭代器实现 __aiter__(返回自身或异步迭代器)与 __anext__(返回可等待对象,结束时抛 StopAsyncIteration)。async for 每次 await __anext__(),适合流式消费异步数据源(消息队列、分页 API、SSE)。
概念解释
- 异步生成器(
async def+yield)自动获得__aiter__/__anext__。 - 异步迭代器同样只能消费一次。
原理流程
async for先调用__aiter__取得异步迭代器。- 每轮
await __anext__()取下一个值。 - 收到
StopAsyncIteration结束循环。
代码或图示
async def pages(client, url):
while url:
resp = await client.get(url)
data = resp.json()
yield data["items"]
url = data.get("next")
async def main():
async for items in pages(client, "/api/items"):
handle(items)
常见误区
async for只能在async def内使用。- 退出时需
aclose()释放资源,或放在async with中;与同步迭代混用时,不要在__anext__里做长时间阻塞。
追问
StopAsyncIteration和StopIteration为什么要分开?答:异步协议需要独立的终止信号,避免与生成器 PEP 479 规则混淆。- 异步生成器能
send吗?答:不能,asend仅用于yield表达式接收值。 - 消费中途
break会怎样?答:需显式aclose(),否则资源延迟释放。
04.7.4-022 异步生成器(async yield)有什么限制?
一句话结论
异步生成器用 async def + yield,产出需 async for 消费;它不能直接 return value(会 SyntaxError),不能与同步 for 混用,取消时要确保 finally 中的 await 不被再次取消。
概念解释
- 每个
__anext__返回协程,事件循环驱动。 - 异步生成器常用于数据库游标、流式响应、WebSocket 读取。
原理流程
async for每轮调用__anext__得到协程并 await。- 生成器在
yield处暂停,等待下一次拉取。 aclose()在暂停点抛GeneratorExit,finally可await清理。
代码或图示
async def stream(ws):
try:
async for msg in ws:
yield msg
finally:
await ws.close()
常见误区
- 不要在异步生成器里长期持有连接而不关闭;
yield不能在finally里,关闭阶段的 yield 会 RuntimeError。 - 异步生成器单游标,不能并发消费;需要并发就拆成多个独立生成器。
追问
- 为什么不能
return值?答:异步迭代协议没有返回值通道,StopAsyncIteration不带 value。 yield能在finally里吗?答:不能,关闭阶段的 yield 会 RuntimeError。- 异步生成器能并发消费吗?答:不能,单游标;需要并发就拆成多个独立生成器。
04.7.4-023 如何给协程加超时?
一句话结论
用 asyncio.wait_for(coro, timeout) 或 async with asyncio.timeout(t)(3.11+)。超时会取消内部任务并抛 TimeoutError;注意超时只是“停止等待”,底层操作若不可取消仍可能在后台继续。
概念解释
- 3.11 的
asyncio.timeout是上下文管理器,可包裹多步操作。 - 超时后要区分“业务超时”与“取消”,避免把
CancelledError当成超时吞掉。
原理流程
wait_for把协程包装成 Task,启动超时定时器。- 任务先完成则返回结果;超时则
cancel()并等待取消完成,抛 TimeoutError。 - 取消传播到所有
await点,但同步阻塞的线程池任务无法真正中断。
代码或图示
async def fetch():
try:
return await asyncio.wait_for(client.get(url), timeout=3)
except asyncio.TimeoutError:
return None
常见误区
- 嵌套超时要取最小值,避免内外层互相覆盖。
- 不建议用
wait_for包整个请求链路:单点超时容易掩盖慢环节,应在每层设合理超时;3.11 起asyncio.TimeoutError是内建TimeoutError的别名,取消是另一条路径。
追问
- 超时后底层请求真的停了吗?答:协程被取消,但已提交的 IO 可能仍在完成,需要驱动层支持取消。
- 为什么不建议用
asyncio.wait_for包整个请求链路?答:单点超时容易掩盖慢环节,应在每层设合理超时。 TimeoutError与CancelledError什么关系?答:3.11 起asyncio.TimeoutError是内建TimeoutError的别名,取消是另一条路径。
04.7.4-024 协程取消是怎么工作的?CancelledError 该怎么处理?
一句话结论
task.cancel() 请求取消,任务在下一个 await 点抛 CancelledError;协程应让它继续传播(不要吞掉),只在 finally 里做清理。若确实需要抑制,必须重新 raise,否则会破坏调用方的超时/关闭逻辑。
概念解释
- 取消是协作式的:没有
await的纯计算段不会被中断。 asyncio.shield(task)可保护关键段不被外层取消。
原理流程
cancel()在任务上设置取消请求。- 任务到达下一个
await点时抛CancelledError。 - 协程在
finally中清理后让异常继续传播;取消完成后任务状态为 cancelled。
代码或图示
async def worker():
try:
await long_task()
finally:
await cleanup() # 保持简短、幂等
task = asyncio.create_task(worker())
task.cancel()
常见误区
CancelledError在 3.8 起继承BaseException,不会被except Exception捕获,这是刻意设计;吞掉取消会破坏超时/关闭逻辑。finally中的await若再次被取消,可能抛出并覆盖原异常,清理要短且幂等;服务优雅停机时先cancel()所有任务再gather(return_exceptions=True)等待收尾。
追问
- 为什么
CancelledError继承 BaseException?答:防止被宽泛的except Exception吞掉导致取消失效。 - 取消后
task.done()为 True 吗?答:取消完成后是 done,task.cancelled()为 True。 - 如何等待一批任务优雅退出?答:
await asyncio.gather(*tasks, return_exceptions=True)。
04.7.4-025 asyncio.gather、as_completed、wait 有什么区别?
一句话结论
gather 并发运行并「按输入顺序」返回结果,默认一个失败就向外抛(其余任务不取消);as_completed 按「完成先后」逐个 yield,适合流式处理;wait 按「完成状态」返回 done/pending 集合,可选 FIRST_COMPLETED 等策略。
概念解释
gather(return_exceptions=True)把异常作为结果返回,不中断其他任务。- 三者都不会自动限制并发数,高并发需配
Semaphore。
原理流程
gather收集所有任务结果,按输入顺序对齐返回列表。as_completed按完成先后把 future 逐个产出。wait按策略等待,返回 done 与 pending 两组 future。
代码或图示
results = await asyncio.gather(*[fetch(u) for u in urls])
for fut in asyncio.as_completed([fetch(u) for u in urls]):
print(await fut)
常见误区
gather中一个任务失败,其他任务不会自动取消,仍在后台跑(可能产生资源浪费)。- 结果顺序:
gather保证与输入一致;as_completed按完成时间;wait更底层,可只等第一个完成并继续处理剩余任务。
追问
gather中一个任务失败,其他任务会停吗?答:不会自动取消,仍在后台跑(可能产生资源浪费)。- 结果顺序能保证吗?答:
gather保证与输入一致;as_completed按完成时间。 - 怎么限制同时发起的请求数?答:
async with sem: await fetch()包在任务里,或分批gather。
04.7.4-026 异步中如何做限流与并发控制?
一句话结论
用 asyncio.Semaphore(n) 限制同时进行的操作数,asyncio.Queue 做生产者-消费者缓冲,令牌桶/漏桶实现速率限制。注意信号量要在 finally 释放,避免异常路径泄漏配额。
概念解释
- 队列
maxsize提供背压:满时await put阻塞生产者。 - 并发数要结合下游容量(连接池、DB 最大连接)设定,不要只看本服务。
原理流程
- 信号量内部计数,进入临界区前
acquire,计数为 0 则挂起等待。 async with sem:退出时自动release,异常路径也释放。- 队列缓冲生产与消费速度差,满时生产者挂起形成背压。
代码或图示
sem = asyncio.Semaphore(10)
async def fetch(url):
async with sem:
return await client.get(url)
await asyncio.gather(*[fetch(u) for u in urls])
常见误区
- 信号量是逻辑并发闸门,连接池是物理连接复用,二者需匹配。
- 固定窗口/令牌桶可用
asyncio.sleep补时间差实现;限流指标要可观测(等待时长、排队长度)。
追问
- 为什么不直接
gather几千个请求?答:连接数、内存、下游压力都会失控,且容易触发限流。 - 信号量和连接池有什么区别?答:信号量是逻辑并发闸门,连接池是物理连接复用,二者需匹配。
- 队列满了会怎样?答:生产者
await put挂起,自然形成背压。
04.7.4-027 协程和线程相比有什么优势和限制?
一句话结论
协程是用户态、单线程内的协作式并发,切换成本极低、可支撑上万并发,适合 IO 密集;限制是不能利用多核、任一阻塞调用会拖垮全局、调试与生态要求全链路异步。
概念解释
- 线程需要锁保护共享数据;协程单线程内无抢占,但仍需注意
await点的交错。 - CPU 密集用多进程;IO 密集用协程;简单脚本用线程。
原理流程
- 协程切换是函数调用级,在用户态完成,无需内核调度。
- 线程切换涉及内核调度与栈,成本微秒级。
- 协程栈是堆上的帧链,深递归同样受限。
代码或图示
# IO 密集:协程
async def many():
await asyncio.gather(*[fetch(u) for u in urls])
常见误区
- 协程要求所有 IO 都是异步的,混入同步库会退化。
- 协程单线程不能利用多核;共享状态在
await点可能被其他协程修改,仍需asyncio.Lock;协程数量上限受内存(每个任务有帧与状态)、文件描述符、下游连接数限制。
追问
- 协程为什么不能用多核?答:事件循环单线程,GIL 与调度模型都限制在一个核上。
- 协程需要加锁吗?答:共享状态在
await点可能被其他协程修改,仍需asyncio.Lock。 - 协程数量上限受什么限制?答:内存(每个任务有帧与状态)、文件描述符、下游连接数。
04.7.4-028 协程泄漏和“never awaited”警告怎么排查?
一句话结论
“coroutine was never awaited”说明创建了协程却没被 await 或包装成 Task,函数体从未执行;协程泄漏指 Task 创建后无人等待、异常被吞、或无限创建不回收。排查手段:asyncio.all_tasks()、开启 debug 模式、检查 create_task 的引用与异常处理。
概念解释
- 常见原因:忘记
await、在同步函数里调用async def、异常分支提前 return。 - Task 异常若无人
await,只在 GC 时打日志“Task exception was never retrieved”。
原理流程
- 未被等待的协程对象析构时,解释器输出 never awaited 警告。
create_task返回的 Task 若不保存引用,事件循环只持弱引用,可能被 GC 回收。asyncio.all_tasks()列出当前循环全部任务,可打印栈定位卡住的协程。
代码或图示
task = asyncio.create_task(work()) # 保存引用
...
await task # 并处理异常
常见误区
create_task必须保存引用:事件循环只持弱引用,强引用丢失后 Task 可能被回收。- 异常被吞需通过
add_done_callback记录,或统一gather(return_exceptions=False);asyncio.run结束会取消剩余任务,可通过其日志发现泄漏;生产可加周期性任务数监控与堆栈采样。
追问
- 为什么 Task 需要保存引用?答:事件循环只持弱引用,强引用丢失后 Task 可能被回收。
- 如何看到所有在跑的任务?答:
asyncio.all_tasks()打印栈,定位卡住的协程。 - 异常被吞了怎么发现?答:给 Task 加
add_done_callback记录异常,或统一gather(return_exceptions=False)。
04.7.4-029 异步编程常见反模式有哪些?
一句话结论
典型反模式:协程里调同步阻塞库;用 asyncio.sleep(0) 轮询代替事件;在循环里串行 await 本可并发;无界 create_task;吞掉 CancelledError;在 async 中做 CPU 密集计算;混用多事件循环。
概念解释
- 忙等:
while not flag: await asyncio.sleep(0.01)浪费调度,应用Event。 - 用同步锁保护异步代码,会阻塞线程;应用
asyncio.Lock。
原理流程
- 可并发的多个
await应收集成 Task 后gather,而非循环内串行等待。 - 并发上限由信号量/队列控制,避免无界创建 Task。
- 阻塞与 CPU 密集操作移出事件循环线程。
代码或图示
# 反模式
for url in urls:
await fetch(url) # 串行
# 正确
await asyncio.gather(*(fetch(u) for u in urls))
常见误区
- 串行
await并非一律错误:若下游要求串行(依赖前一次结果)则必须串行,否则浪费并发。 - 在协程里
time.sleep、requests、同步 ORM 直接拖垮循环;观察 CPU 使用率与循环迭代次数,或用asynciodebug 慢回调日志发现忙等。
追问
- 串行
await一定慢吗?答:若下游要求串行(依赖前一次结果)则必须串行,否则浪费并发。 - 为什么不能用
threading.Lock?答:它会阻塞事件循环线程,应使用asyncio.Lock。 - 如何发现忙等?答:观察 CPU 使用率与循环迭代次数,或用
asynciodebug 慢回调日志。
04.7.4-030 如何用生成器实现一个状态机?
一句话结论
把“状态迁移”写成生成器:每个 yield 表示等待一个输入事件,收到后用 send 推进;状态保存在局部变量里,代码按时间顺序线性书写,比一堆 if state == ... 更易读。
概念解释
- 生成器天然保存“当前状态 + 局部变量”,恢复时从暂停点继续。
- 适合协议解析、订单状态流转、游戏 AI 行为树、重试流程。
原理流程
- 生成器局部变量保存当前状态。
- 每个
yield产出当前状态,send传入事件。 - 按事件与当前状态迁移到下一状态,循环等待下一事件。
代码或图示
def order_fsm():
state = "created"
while True:
event = yield state
if state == "created" and event == "pay":
state = "paid"
elif state == "paid" and event == "ship":
state = "shipped"
常见误区
- 状态机需要可观测时,额外记录状态名与迁移日志。
- 生成器帧不能直接序列化,持久化恢复需把状态与数据抽成显式结构再重建;需要并发多实例时,每个实例一个生成器对象即可。
追问
- 生成器状态机和类实现相比优势?答:状态迁移线性可读、局部变量自然保存、无需散落的方法。
- 如何做持久化恢复?答:生成器帧不能直接序列化,需把状态与数据抽成显式结构再重建。
- 异常事件怎么处理?答:用
throw()注入,或在send的事件里带类型字段统一分发。
本节高频题
- 可迭代对象与迭代器(001)
for的执行机制(002)- 迭代器一次性(003)
yield执行流程(004)yield from(005)- 生成器资源释放(009)
- 生成器与协程关系(014)
await原理(015)- 事件循环调度(016)
- Task/Future/协程(017)
- 协程中阻塞调用(019)
- 超时与取消(023、024)
gather家族(025)- 异步反模式(029)