罗罗编程学习记录
本页内容 展开查看

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。

原理流程

  1. iter(obj) 对可迭代对象调用 __iter__;对序列若没有 __iter__ 会退回 __getitem__ + 下标协议(老式协议)。
  2. 迭代器实现 __next__ 推进游标,耗尽时抛 StopIteration。
  3. 迭代器必须自己返回自己: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 跳出不执行。

原理流程

  1. for 先对目标对象调用 iter() 取得迭代器。
  2. 每轮调用 next(it),把返回值绑定给循环变量。
  3. 收到 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。

概念解释

  • 需要多次遍历时:用列表/元组缓存、用可重复迭代的自定义容器、或每次重新生成。
  • 传参给多个消费者时,明确“谁负责消费”,避免被上游悄悄耗尽。

原理流程

  1. 迭代器内部保存当前游标,__next__ 只向前推进。
  2. 耗尽后游标到达末尾,后续 next 直接抛 StopIteration。
  3. 重新 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 就一行都不执行。

原理流程

  1. 调用生成器函数时只创建生成器对象,函数体不执行。
  2. 首次 next() 从函数开头执行到第一个 yield,交出值并暂停。
  3. 后续 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 语义。

原理流程

  1. yield from 接管子迭代器,逐个把其产出转发给外层调用方。
  2. 外层 send()/throw()/close() 被透传给子生成器。
  3. 子生成器结束后,其 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。

原理流程

  1. send(v) 把 v 作为当前 yield 表达式结果,从暂停点恢复。
  2. throw(...) 在暂停点注入异常,生成器可捕获并继续,否则异常向外传播并结束生成器。
  3. 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 是最经济的用法。

原理流程

  1. 列表推导在求值时把全部元素物化到列表,内存 O(n)。
  2. 生成器表达式只保留当前元素与迭代状态,内存 O(1)。
  3. 生成器表达式作为函数唯一参数时可省括号: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"") 或自写生成器。

概念解释

  • 文本模式按行缓冲,内存占用与最长行相关,不是文件大小。
  • 逐行处理可用生成器做管道:读 → 解析 → 过滤 → 聚合,每步都惰性。

原理流程

  1. 文本模式逐行从缓冲读取,只保留当前行。
  2. 二进制分块循环 read(size),读到空字节结束。
  3. 生成器把块/行逐个产出,消费端按需处理。

代码或图示

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()。

原理流程

  1. 显式 close() 或 GC 回收时,在暂停点抛 GeneratorExit。
  2. 生成器进入 finally 执行清理逻辑。
  3. 生成器互相嵌套时,外层关闭会 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,会先执行清理再传播。

原理流程

  1. 生成器内部抛出普通异常,原样传给调用方并结束生成器。
  2. 生成器内 raise StopIteration 被 PEP 479 转成 RuntimeError 向外传播。
  3. 用 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 拉动上游),不是推模型。

原理流程

  1. 下游对最末级生成器调用 next,逐级向上游拉取元素。
  2. 每级只处理当前元素后产出给下一级。
  3. 某一级抛异常会中断整条管道,需在边界做容错。

代码或图示

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,符合协议。

原理流程

  1. 容器类 __iter__ 里用生成器最简洁:return (x for x in self.data) 或 yield。
  2. 独立迭代器实现 __next__ 自行维护游标,耗尽时抛 StopIteration。
  3. 两者配合实现可重复遍历。

代码或图示

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 重复常量。
  • 消费端一定要有终止条件,且要考虑超时。

原理流程

  1. 生成器/itertools 工具持续产出元素,不自行终止。
  2. 消费端通过 islice 取前 n 项、takewhile 条件满足时取、或 zip 配有限序列截断。
  3. 到达边界后停止驱动生成器。

代码或图示

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)用于流式异步数据。

原理流程

  1. 早期协程复用生成器暂停/恢复能力,由调度器驱动。
  2. 原生协程对象是 types.CoroutineType,不能直接 next(),只能被事件循环/await 驱动。
  3. 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 指令。
  • 协程只提供“暂停能力”,真正并发靠事件循环多路复用。

原理流程

  1. 调用 async def 函数只创建协程对象,函数体不执行。
  2. 遇到 await 时,把控制权交回事件循环,协程挂起并登记回调。
  3. 被等待对象就绪后,回调把协程恢复为可运行,从暂停点继续。

代码或图示

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 密集。

原理流程

  1. 每轮处理就绪回调队列,推进可运行任务。
  2. 计算下次定时器超时,进入 IO 多路复用等待就绪事件。
  3. 就绪事件触发对应回调,把协程重新排到就绪队列。

代码或图示

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。

原理流程

  1. 协程对象描述待执行的计算,未被调度前不运行。
  2. asyncio.create_task(coro) 把协程排入循环并发执行,包装成 Task。
  3. 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。

原理流程

  1. asyncio.run 入口检查当前线程是否已有运行中的循环。
  2. 无循环时创建新循环、运行协程、结束后取消剩余任务并关闭循环。
  3. 已有运行循环时直接抛 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 密集计算。
  • 线程池任务不受协程取消影响,取消后线程仍在跑。

原理流程

  1. 阻塞调用占住事件循环线程,循环无法处理就绪回调与定时器。
  2. 其他协程全部饥饿,直到阻塞调用返回。
  3. 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 管理。

原理流程

  1. 进入 async with 时 await __aenter__,返回值绑定给 as。
  2. 退出时 await __aexit__,传入异常三元组。
  3. 异步生成器版在 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__。
  • 异步迭代器同样只能消费一次。

原理流程

  1. async for 先调用 __aiter__ 取得异步迭代器。
  2. 每轮 await __anext__() 取下一个值。
  3. 收到 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 读取。

原理流程

  1. async for 每轮调用 __anext__ 得到协程并 await。
  2. 生成器在 yield 处暂停,等待下一次拉取。
  3. 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 当成超时吞掉。

原理流程

  1. wait_for 把协程包装成 Task,启动超时定时器。
  2. 任务先完成则返回结果;超时则 cancel() 并等待取消完成,抛 TimeoutError。
  3. 取消传播到所有 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) 可保护关键段不被外层取消。

原理流程

  1. cancel() 在任务上设置取消请求。
  2. 任务到达下一个 await 点时抛 CancelledError。
  3. 协程在 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。

原理流程

  1. gather 收集所有任务结果,按输入顺序对齐返回列表。
  2. as_completed 按完成先后把 future 逐个产出。
  3. 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 最大连接)设定,不要只看本服务。

原理流程

  1. 信号量内部计数,进入临界区前 acquire,计数为 0 则挂起等待。
  2. async with sem: 退出时自动 release,异常路径也释放。
  3. 队列缓冲生产与消费速度差,满时生产者挂起形成背压。

代码或图示

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 密集用协程;简单脚本用线程。

原理流程

  1. 协程切换是函数调用级,在用户态完成,无需内核调度。
  2. 线程切换涉及内核调度与栈,成本微秒级。
  3. 协程栈是堆上的帧链,深递归同样受限。

代码或图示

# 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”。

原理流程

  1. 未被等待的协程对象析构时,解释器输出 never awaited 警告。
  2. create_task 返回的 Task 若不保存引用,事件循环只持弱引用,可能被 GC 回收。
  3. 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。

原理流程

  1. 可并发的多个 await 应收集成 Task 后 gather,而非循环内串行等待。
  2. 并发上限由信号量/队列控制,避免无界创建 Task。
  3. 阻塞与 CPU 密集操作移出事件循环线程。

代码或图示

# 反模式
for url in urls:
    await fetch(url)          # 串行

# 正确
await asyncio.gather(*(fetch(u) for u in urls))

常见误区

  • 串行 await 并非一律错误:若下游要求串行(依赖前一次结果)则必须串行,否则浪费并发。
  • 在协程里 time.sleep、requests、同步 ORM 直接拖垮循环;观察 CPU 使用率与循环迭代次数,或用 asyncio debug 慢回调日志发现忙等。

追问

  • 串行 await 一定慢吗?答:若下游要求串行(依赖前一次结果)则必须串行,否则浪费并发。
  • 为什么不能用 threading.Lock?答:它会阻塞事件循环线程,应使用 asyncio.Lock。
  • 如何发现忙等?答:观察 CPU 使用率与循环迭代次数,或用 asyncio debug 慢回调日志。

04.7.4-030 如何用生成器实现一个状态机?

一句话结论

把“状态迁移”写成生成器:每个 yield 表示等待一个输入事件,收到后用 send 推进;状态保存在局部变量里,代码按时间顺序线性书写,比一堆 if state == ... 更易读。

概念解释

  • 生成器天然保存“当前状态 + 局部变量”,恢复时从暂停点继续。
  • 适合协议解析、订单状态流转、游戏 AI 行为树、重试流程。

原理流程

  1. 生成器局部变量保存当前状态。
  2. 每个 yield 产出当前状态,send 传入事件。
  3. 按事件与当前状态迁移到下一状态,循环等待下一事件。

代码或图示

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)