栈与函数调用机制：协程切换与栈保存

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

协程基础概念：办公室里的自觉换岗

想象一间开放办公室，十几位同事共用几张工位。没有管理员指挥，大家自觉遵守一条规矩：谁坐上去，做完一小段就起身，让下一位接着做。甲写两行方案，乙填三行表格，丙只处理一步审批……看起来零散，整体进度却稳步推进。这种“自觉让位、轮流推进”的分工方式，就是协程的雏形。

协程（coroutine）是一种由程序员自己控制调度、在用户态完成的并发单元。它不依赖操作系统时钟中断来强行打断，而是主动调用 yield（让位）挂起自己，等时机成熟再由调度器 resume（恢复）。yield 与 resume，就是协程世界的呼吸：一呼一吸之间，执行权在多个协程之间交接，谁都不霸占工位。

相比线程的抢占式调度，协程的协作式调度有两大优势。其一，切换时机可控——协程只在明确的挂起点让位，不会在任意指令处被打断，因此保存现场的成本是固定的；其二，切换成本极低——不必陷入内核，保存恢复的只是少量寄存器。直接结果是并发规模的数量级提升：一台 8GB 内存的机器，线程因每个默认 8MB 栈很快耗尽资源，只能开几千个；协程却能开到几十万甚至上百万个。

小步换岗法为什么能容纳更多人？因为每个人占用的家当太少——一张待办卡片就能排队，而线程这“大桌子”摆不下几套。

栈与函数调用：工位上的一摞文件

每张工位上都有那么一摞文件：正在处理的项目 A 在最上面，下面压着之前没看完的项目 B、C。处理任何一件事时，你总是从最上面那份开始；做完合上放一边，继续处理下一份。这一摞“后进先出”的文件，就是程序世界的栈（stack）。

函数调用，就是往这摞文件上放一份新文件。每次调用都会在栈上开辟一块区域，叫栈帧（stack frame），里面装着：参数、返回地址、局部变量、上一层帧指针。返回地址最是关键——它记录“这份文件看完后，回到上一份文件的哪一行继续”。调用约定（ABI）则规定了这些文件栏目的格式：参数怎么传、谁来清理、返回地址放哪一格。call 指令把返回地址压栈并跳转，ret 指令弹出返回地址放回 PC（程序计数器）。栈指针 SP 永远指向栈顶——就像你的手指，始终停在那份正在读的文件上。

理解了文件堆的规则，协程切换的秘密就揭开一半了：当你想从工位起身去隔壁帮忙，必须保证这摞文件原封不动——这正是“保存栈”的含义。

上下文切换：换岗前记三样东西

在小步换岗制度下，起身之前你必须完成三件事：把手边便利贴上的关键数字抄进随身小本子（寄存器）；记住手指停在文件堆的哪一份（栈指针）；记住正看到那一页的第几行（程序计数器）。三样记完，才算“保存现场”。

这三样东西合起来，叫执行上下文（context）。寄存器是 CPU 内部的高速暂存单元，保存当前运算的中间值，像便利贴上随手写的关键数字；栈指针 SP 指向当前栈顶帧，像停在第几份文件；程序计数器 PC 指向下一条要执行的指令，像读到第几行。把三者写入一个上下文结构体，是保存现场；反向从结构体加载回寄存器、设置好 SP 与 PC，是恢复现场。一次协程 switch 切换，本质就是“保存旧协程现场 + 恢复新协程现场”——在汇编层面只有几十条指令。

“小本子”就是全部家当。正因为要抄写的东西极少，协程换岗才能快到让人毫无察觉。

有栈协程：每人一张专属工位

有栈协程的方案很直白：给每个协程配一张独立的小工位。工位不用大，够放下自己的文件堆就行；再配一个小本子（上下文对象）。换岗时，把旧工位的文件堆原封不动留好，揣上小本子走向下一张工位——名下那张桌子永远等着你回来。

有栈协程（stackful coroutine）在创建时通过 malloc 分配一块独立栈，常见 64KB 到 1MB。切换流程分两步：switch 把当前寄存器组、SP（旧栈帧位置）、PC（挂起位置）写入协程 A 的上下文对象；然后让 SP 指向协程 B 的栈顶、PC 指向 B 上次的恢复点，直接跳转执行。resume 本质是一次目标为 B 的 switch。因为拥有完整调用栈，有栈协程可以在任意深度的嵌套函数中挂起——哪怕在第三层函数里 yield，整条调用链都安然保存。

换桌子的速度取决于本子有多厚——而有栈协程的“本子”只有几十个字，所以再深的调用链也能瞬间换岗。

无栈协程：共享长桌上的一页待办清单

无栈协程换了个思路：大家共用一张长桌（调用者的栈），每人只拿一张待办卡片，上面写着“做到第几步”。轮到你时，按卡片上的步骤号从清单里找出对应的步骤继续走——谁也不需要一张专属桌子。

无栈协程（stackless coroutine）在编译期被编译器改写成一台状态机：函数体被拆成若干代码段，每个 yield 对应一个状态分支；原先的局部变量全部变成状态结构体的字段，不再依赖调用栈保存。运行时它复用调用者的栈，在别人的栈帧上执行，因此不需要独立栈内存。代价是挂起只能发生在协程函数体自身的 yield 处——被调用的普通函数里不能中途挂起整条协作链。换来的是极小的内存占用：一个状态对象往往只有几十字节。

一张卡片 vs 一抽屉文件——无栈协程把省字发挥到极致，代价是不能随意在嵌套函数深处挂起。

协程与线程对比：换岗的账本

现在给办公室算一笔账。线程切换像惊动管理员的大搬家：系统调用陷入内核、调度器选人、特权级切换、刷新缓存，动静大、时间长；协程切换像同事间递个眼色的小换岗：纯用户态几十条指令，保存恢复寄存器、换 SP、跳 PC，干净利落。

账本上有两组数字最能说明差距。耗时方面，线程切换约 1~10 微秒，协程切换约 20~200 纳秒，相差一到两个数量级；内存方面，线程默认栈 8MB，几千个就把内存吃光，有栈协程栈 64KB、无栈协程只要几十字节，十万并发轻松拿下。这也决定了选型：IO 密集、请求量大、等待多的场景（网络服务、推理网关）选协程；CPU 密集、要吃满多核并行的计算场景，仍要用线程做并行，再配合协程处理每核上的高并发。

账本翻到最后，结论清晰：协程解决的是“等得多”的问题，线程解决的是“算得狠”的问题，两者常常手拉手出现。

实践应用：让换岗制度落地

小步换岗从办公室默契变成公司制度，靠的是调度员和排班表。落到工程里，这个“调度员”就是协程库：从 libco 的 switch 汇编、Go 的 goroutine 调度器，到 Python asyncio 的事件循环，内核都是同一件事——在恰当的时机 yield，在条件满足时 resume。

最典型的落地是异步 IO 结合：一个网络服务有上万个连接在等数据，传统线程模型让每个线程傻等 recv 返回；协程模型则让协程在等待时挂起，把 CPU 让给其他就绪协程，数据到达再由事件循环（epoll/kqueue）唤醒。性能调优的要点也随之明确：不要让协程里出现阻塞调用（如同步磁盘 IO），否则整条协作链被卡死；控制协程数量不要无脑开满；用有栈协程应对需要嵌套挂起的复杂调用链，用无栈协程压缩内存开销。

好制度让每个人各司其职、不空等。理解了栈与协程的底层原理，你再看框架的并发模型时，就不再是黑盒——而是那间办公室里，一次漂亮的换岗。

AI 应用场景

Python 演示

class StackfulCoroutine:    """有栈协程：每个协程拥有独立栈与上下文对象"""     def __init__(self, name, max_dep):        self.name = name        self.stack = []              # 独立栈：保存自己的栈帧        self.pc = 0                  # 程序计数器：已执行的调用数        self.max_dep = max_dep     def call(self, n=1):        """模拟 n 次函数调用，每次压入一个栈帧"""        for _ in range(n):            if self.pc >= self.max_dep:                return False            self.pc += 1            self.stack.append("frame" + str(self.pc))        return True     def status(self):        top = self.stack[-1] if self.stack else "空"        return f"[{self.name}] pc={self.pc} 栈深={len(self.stack)} 栈顶={top}"  def switch(a, b):    """仿 switch：保存 a 现场（栈留在对象里），恢复 b 现场"""    print(f"{a.status()} -> 保存现场")    print(f"{b.status()} -> 恢复现场，继续执行")  def stackless_gen(name, steps):    """无栈协程：生成器被编译器改写成状态机"""    k = 0    while k < steps:        k += 1        yield k      # 挂起点：状态 k 保存在生成器对象内部    return k  def main():    print("=== 有栈协程：switch 切换 ===")    a = StackfulCoroutine("A", 4)    b = StackfulCoroutine("B", 3)    a.call(2)    b.call(1)    switch(a, b)      # A 挂起，B 恢复    a.call(1)    print(a.status(), "-> A 的栈原样保留，继续压栈")     print("\n=== 无栈协程：状态机推进 ===")    g1 = stackless_gen("C", 3)    g2 = stackless_gen("D", 2)    print("C 执行一步:", next(g1))    print("D 执行一步:", next(g2))    print("C 再从挂起点恢复:", next(g1))  if __name__ == "__main__":    main()

1. self.stack = []每个有栈协程的“独立栈”，用列表模拟，切换时原样保留
2. self.stack.append("frame" + str(self.pc))调用函数即向自己的栈压入一个栈帧
3. def switch(a, b)仿 switch：打印 A 的现场被保存、B 的现场被恢复
4. yield k无栈协程的挂起点，状态 k 由生成器对象内部保存，不占独立栈
5. next(g1)一次 resume 操作，让协程从上次挂起的位置继续执行
6. if __name__ == "__main__": main()可执行入口，直接运行观察两种协程模型

常见误区

面试题