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

01.1.1.3 协程与用户态调度

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.1 操作系统 / 01.1.1 进程线程与调度

01.1.1.3-001 协程是什么?和线程的本质差别是什么?

一句话结论

协程(coroutine)是运行在用户态、由语言运行时或库调度的轻量级执行单元,切换不经过内核调度器;线程是内核调度的执行单元,协程在一个或多个内核线程上多路复用运行。

概念解释

  • 调度主体:线程由内核调度;协程由运行时/库在用户态轮转。
  • 栈:协程拥有独立小栈(可动态增长),内存远小于线程栈;线程栈通常预留数 MiB。
  • 阻塞语义:协程阻塞等待时应让出载体线程,由运行时安排其他协程;纯用户态线程(N:1)遇到阻塞系统调用会卡住整组。

原理流程

  1. 应用启动少量内核线程作为载体。
  2. 运行时在载体上调度大量协程,遇到等待点切到其他协程。
  3. 等待事件就绪后,协程被重新放回可运行队列,择机上载体执行。

代码或图示

内核线程 M1 ─┬─ 协程 G1 ─ 等待 → 切走
             ├─ 协程 G2 ─ 运行
             └─ 协程 G3 ─ 运行
内核线程 M2 ─┬─ 协程 G4
             └─ 协程 G5

常见误区

  • 以为协程是“用户态线程所以并发性一样”:协程并发由运行时调度,真正并行仍要多个载体线程。
  • 以为协程不需要同步:同一时刻一个载体只跑一个协程,但多载体并发下共享数据仍需同步。

追问

  • 协程比线程轻在哪?答:栈小、切换在用户态、创建销毁不进内核、可支撑数万到数十万并发(具体上限受内存与运行时限制,需实测)。
  • 协程和“绿色线程”什么关系?答:绿色线程泛指由运行时调度、不直接对应内核线程的执行单元;协程是绿色线程的一种常见实现形态。

01.1.1.3-002 协程栈怎么分配?大小和线程栈有什么不同?

一句话结论

协程栈初始很小(如 Go goroutine 初始栈约 2 KiB,具体以版本为准,待确认),按需要分段/复制扩容;线程栈创建时预留较大容量(默认 MiB 级),二者内存占用模型完全不同。

概念解释

  • 初始小栈:降低大量协程的内存基线;运行中栈不足再扩容。
  • 扩容方式:分段栈(stack segment 链接)或连续栈复制(分配新更大栈、拷贝旧帧、更新指针)。
  • 栈回收:协程退出后栈归还运行时池;大栈在切换时可能被放回缓存复用。

原理流程

  1. 创建协程分配初始小栈与栈指针。
  2. 函数调用加深、栈空间不足 → 运行时触发扩容。
  3. 复制/链接新栈段,更新帧指针;协程退出后栈回收或入池。

代码或图示

线程栈:创建即预留 ~MiB 级区域
协程栈:初始 KB 级 → 按调用深度动态增长 → 退出回收/复用

常见误区

  • 以为协程栈无限增长不占内存:栈随深度增长,深递归同样会耗尽或触发扩容,连续栈复制还有拷贝开销。
  • 以为初始栈大小是语言保证不变值:版本间可能调整,写代码不依赖具体数字,以本机文档/实测为准。

追问

  • 连续栈复制时为什么要更新指针?答:栈搬到新地址,栈上保存的返回地址、指针都要按偏移修正,否则指向旧栈。
  • 高并发下协程内存怎么估算?答:内存 ≈ 协程数 × 平均栈深 × 单帧大小 + 运行时元数据;空闲协程栈小,阻塞持有大栈的协程占用更高。

01.1.1.3-003 协程切换时保存和恢复什么?

一句话结论

协程切换保存 callee-saved 寄存器、栈指针、程序计数器(恢复点)与协程上下文状态,在用户态完成;不保存内核现场、不换页表、不进入调度器队列操作。

概念解释

  • 保存内容:栈指针、返回地址/PC、被调用者保留寄存器、运行时上下文(所在队列、状态)。
  • 恢复:从目标协程上下文读回寄存器与栈指针,从让出点继续执行。
  • 对比线程:线程切换要陷入内核、由内核保存完整硬件现场并选任务;协程切换是运行时内的函数级跳转。

原理流程

  1. 协程到达等待点,运行时把当前寄存器/栈指针存入上下文。
  2. 选择下一个可运行协程,恢复其上下文。
  3. 从其上次让出的位置继续执行。

代码或图示

保存:SP、PC(恢复点)、callee-saved 寄存器、运行时状态
恢复:载入目标协程 SP/PC/寄存器 → 从让出点继续
全程用户态,无内核陷入

常见误区

  • 以为协程切换要保存全部通用寄存器:按 ABI 只保存约定保留项,调用者保存项由调用约定处理。
  • 以为切换成本为零:寄存器与栈上下文存取、运行时队列操作仍有开销,只是远小于内核线程切换。

追问

  • 协程切换什么时候发生?答:等待 IO/通道/锁、主动让出、运行时调度点检查到需要切换;协作式模型只在显式让出点切换。
  • 切换后局部变量还在吗?答:在,局部变量在协程自己的栈上,挂起期间栈与上下文保留。

01.1.1.3-004 用户态调度和内核态调度的核心差异是什么?

一句话结论

内核态调度由操作系统决定何时切换、选谁运行,上下文切换进内核;用户态调度由运行时决定协程轮转,内核只看到少量载体线程,调度策略可按应用场景定制。

概念解释

  • 内核调度:统一公平、阻塞语义完整,但策略固定、切换成本高、对应用意图不可见。
  • 用户调度:运行时了解业务等待点,可做定向唤醒、批量调度;但要自己处理阻塞、并行与公平性。
  • 混合:M:N 模型把用户协程映射到内核线程,兼顾轻量与真实并行。

原理流程

  1. 内核线程被调度上 CPU。
  2. 运行时在其上选择协程执行。
  3. 协程让出 → 运行时换另一个;载体阻塞 → 内核调度器换走载体。

代码或图示

内核调度器:选载体线程(M)
运行时调度器:选协程(G)在 M 上运行
两层调度:内核管载体,运行时管协程

常见误区

  • 以为用户态调度可以绕过内核并行:并行仍依赖多载体线程,内核调度器决定载体上不上 CPU。
  • 以为用户态调度器能完全自定义而不考虑内核公平:载体被内核抢占时,其上所有协程一起暂停。

追问

  • 用户态调度的策略优势有哪些?答:按业务优先级/亲和性调度、批量唤醒、协程级排队,避免内核不了解业务语义的盲目公平。
  • 用户态调度要自己解决什么问题?答:阻塞映射、栈管理、公平与饥饿、调试与栈回溯、与内核信号/中断的交互。

01.1.1.3-005 Go 的 GMP 调度模型是什么?

一句话结论

GMP 由 G(goroutine 协程)、M(内核线程载体)、P(逻辑处理器,持有可运行 G 队列)组成;P 限制并行度(数量默认等于 GOMAXPROCS),M 必须绑定 P 才能执行 G,支持本地队列、全局队列与 work-stealing。

概念解释

  • G:协程,含栈与上下文;M:操作系统线程;P:调度上下文,持有本地可运行队列与运行时状态。
  • 本地队列:每个 P 有一份 LRQ;全局队列 GRQ 兜底;P 本地空了从全局或其他 P 偷取 G。
  • 阻塞处理:G 发起阻塞系统调用时 M 与 P 解绑,P 可交给其他 M;返回后若 G 仍可运行,放回队列。

原理流程

  1. M 绑定 P,从 P 本地队列取 G 执行。
  2. G 阻塞 → M 与 P 分离,P 挂到其他 M 继续跑。
  3. 本地队列空 → 先查全局队列,再从其他 P 偷取一半 G。

代码或图示

P1 ─ LRQ[G1 G2] ─ M1
P2 ─ LRQ[G3]     ─ M2
全局队列 GRQ:兜底
偷取:P2 空 → 从 P1 LRQ 偷一半

常见误区

  • 以为 M 数量等于 GOMAXPROCS:M 是内核线程,可多于 P;阻塞/系统调用场景会创建额外 M。
  • 以为 goroutine 一定并行跑在多个核上:受 P 数量(GOMAXPROCS)限制,且阻塞调度细节随版本演进。

追问

  • GOMAXPROCS 控制什么?答:P 的数量即可用并行度;容器环境早期需识别 cgroup 限制,避免默认按整机核数设置(运行时版本已逐步适配,待确认本机行为)。
  • 一个 G 阻塞在系统调用上会发生什么?答:M 随 G 进入阻塞,P 解绑交给新 M;系统调用返回后,若 G 不能立即继续,被放回队列,M 归还。

01.1.1.3-006 什么是 M:N 调度?work-stealing 怎么工作?

一句话结论

M:N 指 M 个用户协程映射到 N 个内核线程上多路复用;work-stealing 指空闲的处理器从繁忙处理器的本地队列“偷”走一批协程执行,平衡负载且减少全局队列竞争。

概念解释

  • M:N 目标:既获得协程轻量性,又利用多内核线程并行。
  • 偷取策略:本地队列空 → 查全局 → 从其他 P 队列偷一半(或按实现取尾部一批)。
  • 收益:减少全局锁竞争,负载在处理器间自动均衡。

原理流程

  1. 每个处理器维护本地双端队列。
  2. 本地消费一端;偷取者从另一端取一批。
  3. 持续偷取直到各队列均衡或全部空闲。

代码或图示

队列 A:[G1 G2 G3 G4]   队列 B:空
B 偷取:从 A 尾部取 G3 G4 → B 执行

常见误区

  • 以为 work-stealing 只在启动时做一次:运行期持续按队列状态偷取。
  • 以为偷取没有成本:跨处理器取任务涉及队列访问与缓存迁移,只是比全局队列加锁更优。

追问

  • 哪些运行时用了类似模型?答:Go GMP、Java 虚拟线程调度器、部分 Erlang/BEAM 调度器;具体队列与偷取策略各有实现差异。
  • 任务有亲和性时偷取有什么代价?答:协程绑定的数据/缓存随任务迁移到别的处理器,本地性下降;调度器需权衡均衡与亲和。

01.1.1.3-007 goroutine 栈扩容是怎么实现的?

一句话结论

Go 采用连续栈:栈不足时分配一块更大的新栈,把旧栈帧完整复制过去,修正所有指向旧栈的指针,再释放旧栈;栈增长有检查门槛,避免每次调用都复制。

概念解释

  • 栈边界检查:函数序言检查栈空间是否足够,不足调用栈扩容逻辑。
  • 复制修正:栈上参数、局部指针、返回引用都按偏移调整到新栈位置。
  • 收缩:栈使用量长期低于阈值时可缩容(机制随版本,待确认),避免大栈长期占用。

原理流程

  1. 调用前检查剩余栈 < 需求 → 触发扩容。
  2. 分配新栈(约为旧栈两倍,具体倍率以实现为准)。
  3. 拷贝旧帧、修正指针、切到新栈、释放旧栈。

代码或图示

旧栈 [帧 A|帧 B|帧 C]
  → 分配新栈 2× → 复制 A B C → 修正指针 → 释放旧栈

常见误区

  • 以为扩容只是“加一段链接上去”:Go 历史上曾用分段栈,现代实现为连续栈复制,不要混用说法。
  • 以为栈复制开销可忽略:深大栈复制有 CPU 与内存成本,高频短生命周期大栈任务需关注。

追问

  • 怎么观察栈增长/复制?答:运行时指标与 trace 工具查看栈大小分布;pprof goroutine 栈剖面看深度与占用。
  • 深递归在 goroutine 里有什么表现?答:不断触发扩容直至内存受限;应改迭代或限制递归深度。

01.1.1.3-008 Java 虚拟线程的载体(carrier)模型是什么?

一句话结论

虚拟线程由平台线程(载体线程池)承载运行;虚拟线程阻塞时被从载体上卸载(unmount),载体执行其他虚拟线程,事件就绪后再找载体挂载(mount)恢复执行;映射关系是 M:N。

概念解释

  • 载体池:数量有限的平台线程,对应内核线程;虚拟线程数量可以远多于载体。
  • 挂载/卸载:阻塞操作把虚拟线程栈与状态保存,载体释放;完成后重新调度挂载。
  • 限制:与平台线程混用时(synchronized 块内阻塞)会钉住载体(pin),卸载不彻底;高并发阻塞场景推荐 ReentrantLock。

原理流程

  1. 载体从载体池取虚拟线程挂载执行。
  2. 遇到阻塞 → 卸载虚拟线程,载体取下一个。
  3. 阻塞完成 → 虚拟线程入队,等待载体挂载恢复。

代码或图示

载体线程池(少量平台线程)
  挂载 VT1 → 阻塞卸载 VT1 → 挂载 VT2 → ...
VT:数量众多,栈小,阻塞不占载体

常见误区

  • 以为虚拟线程把每个平台线程都替换掉:载体仍是平台线程,虚拟线程在其上多路复用。
  • 以为 synchronized 内阻塞也能自由卸载:持有时可能钉住载体,削弱并发度;这是版本与实现相关的注意点,待确认本机行为。

追问

  • 虚拟线程适合什么场景?答:大量阻塞式任务(IO、RPC、等待下游),用同步写法获得接近异步的并发量;CPU 密集任务收益有限。
  • 虚拟线程泄漏怎么识别?答:未完成的任务一直持有虚拟线程与栈,监控活跃虚拟线程数、堆积任务队列与下游阻塞点。

01.1.1.3-009 协程遇到阻塞系统调用怎么办?

一句话结论

运行时把阻塞操作分两类:可异步化的(网络、通道、定时)封装为等待事件并让出载体;必须阻塞内核线程的调用(部分本地 IO、CPU 重算)会占用载体,运行时可补充新载体避免并行度下降。

概念解释

  • 网络/定时:注册事件到多路复用器,协程挂起,载体跑其他协程。
  • 阻塞系统调用:载体随调用进入内核睡眠;运行时再开一个载体维持 P/并行度。
  • 风险:若大量协程同时发起原生阻塞调用,载体被占满,退化为线程模型。

原理流程

  1. 协程调用 IO:运行时判断是否可异步挂起。
  2. 可挂起 → 注册事件、让出载体;不可挂起 → 载体阻塞,补充新载体。
  3. 事件就绪 → 协程入队,等待挂载继续。

代码或图示

非阻塞事件(net/timer):挂起等待,释放载体
阻塞系统调用:载体随之内核睡眠 → 运行时补载体

常见误区

  • 以为用了协程,任何阻塞调用都不占线程:未被运行时封装的原生阻塞仍占载体。
  • 以为补充载体无限免费:载体是内核线程,数量过多回到线程模型的切换与内存问题。

追问

  • 代码里怎么避免钉死/占满载体?答:阻塞点用运行时封装的异步 API;重计算拆分让出;监控载体/线程数与阻塞点。
  • 文件 IO 在协程模型里通常怎么处理?答:多数运行时把阻塞文件 IO 放到辅助线程池,避免占住主载体;具体实现随语言/版本。

01.1.1.3-010 协作式让出和抢占式调度有什么区别?

一句话结论

协作式调度只在协程主动让出(等待点、显式 yield)时切换;抢占式由运行时在调度点检查运行时长,超时强制挂起当前协程,防止单个协程霸占载体。

概念解释

  • 协作式:实现简单,但一个死循环协程会一直占住载体,其他协程饥饿。
  • 抢占式:运行时周期性/在安全点检查执行时间,到点挂起;需要可插入检查点的运行时支持。
  • Go 早期偏向协作+信号驱动抢占,现代版本有定时抢占机制(细节随版本,待确认)。

原理流程

  1. 协作式:协程调用等待/yield → 运行时切换下一个。
  2. 抢占式:调度点检查运行时长/调度标志 → 超时挂起 → 入队等待。
  3. 被抢占协程恢复时从检查点继续。

代码或图示

协作式:G1 跑到主动让出 → 才轮到 G2
抢占式:G1 超时 → 运行时挂起 → G2 执行 → G1 稍后恢复

常见误区

  • 以为协作式模型可以靠语言语法防止死循环霸占:没有主动让出点就无法切换。
  • 以为抢占点可以插在任意机器指令上:通常在函数调用/安全点检查,长循环内部可能没有检查点。

追问

  • 抢占式调度的检查点插在哪里?答:函数序言、循环回边、运行时调用点;纯计算 tight loop 内部可能缺检查点,需要信号/定时机制兜底。
  • 被强占的协程现场怎么保存?答:栈与寄存器上下文保存,恢复时从检查点继续,语义上等价于一次正常挂起。

01.1.1.3-011 async/await 和事件循环是什么关系?

一句话结论

async/await 是语言层的协程语法:挂起点把后续回调注册到事件循环队列,事件循环在 IO/定时就绪后恢复执行;它是单载体 N:1 式用户态调度的典型形态。

概念解释

  • 异步函数被调用返回 Promise/可等待对象,遇到 await 挂起当前执行流。
  • 事件循环轮询就绪事件,回调进入微任务/宏任务队列,恢复 async 函数后续代码。
  • 单线程执行:同一时刻只有一段异步代码在跑,并发来自 IO 等待期间的轮转。

原理流程

  1. 调用 async 函数执行到第一个 await。
  2. 等待未就绪 → 挂起,控制权回到事件循环。
  3. 事件就绪 → 回调入队 → 事件循环恢复函数后续逻辑。

代码或图示

async fn: 代码 → await A(挂起)→ …事件就绪… → 恢复后续
事件循环:轮询就绪 → 微任务/宏任务队列 → 恢复执行

常见误区

  • 以为 await 后面的代码开了新线程:没有,恢复时仍在事件循环线程执行。
  • 以为 async 函数自动非阻塞:内部的同步重计算照样阻塞事件循环。

追问

  • 微任务和宏任务在恢复顺序上怎么排?答:每轮事件循环间隙先清空微任务队列再取下一个宏任务,细节见 04.2.1 相关分册。
  • CPU 密集任务在 async 模型里怎么办?答:卸载到工作线程/进程,避免阻塞事件循环主线程。

01.1.1.3-012 协程泄漏怎么产生?怎么排查?

一句话结论

协程泄漏指协程启动后一直阻塞/等待无法退出,持续占用栈与元数据;常见于等待永不就绪的通道、未取消的任务、 goroutine 里阻塞在无缓冲通道或外部依赖。

概念解释

  • 泄漏来源:任务未响应取消信号、通道无人发送、阻塞在永远不返回的调用、引用被持有无法回收。
  • 观测:活跃协程数单调上涨、栈剖面堆积在同一等待点、内存缓慢增长。
  • 排查:运行时协程剖面(pprof goroutine)、导出协程数与状态指标、对账启动/退出数量。

原理流程

  1. 任务启动协程 → 等待点阻塞。
  2. 取消/超时未传递,协程一直挂起。
  3. 反复触发后协程数与内存累积。

代码或图示

监控:goroutine 数趋势 + pprof goroutine 堆栈
判据:同一等待点堆栈反复出现、数量随时间单调上涨

常见误区

  • 以为协程轻量就不会泄漏:轻量只是单个体积小,数量累积后内存与调度开销同样可观。
  • 只看总内存不看协程数:早期泄漏内存增长慢,协程数与阻塞点更早暴露问题。

追问

  • 怎么预防协程泄漏?答:任务带取消/超时上下文,所有等待点响应取消;启动即记录职责与归属;下游调用设置超时。
  • 怎么定位具体卡在哪个等待点?答:抓协程剖面看大多数协程的阻塞栈,对应到通道、锁或 RPC 调用,再查对端为何不就绪。

01.1.1.3-013 协程上下文切换成本大概是什么量级?

一句话结论

定性上协程切换显著低于内核线程切换,线程切换又高于进程切换;但绝对数值受架构、运行时、负载影响,必须本机压测,不照搬经验数字。

概念解释

  • 成本构成:寄存器/栈保存恢复、队列操作、缓存影响;协程不陷入内核、不换地址空间。
  • 测量方法:基准测试循环切换两个执行体,统计单次切换耗时;对比线程 pthread 往返。
  • 标注:具体纳秒数随 CPU 架构、频率、运行时版本变化,文档中不写死数值。

原理流程

  1. 写基准:两个执行体互相切换 N 次计时。
  2. 分别测协程、线程、进程切换。
  3. 比较单次均值与分布,结论标注“本机实测”。

代码或图示

定性:进程切换 > 线程切换(内核态)> 协程切换(用户态)
定量:以本机 benchmark 为准,记录架构/版本/均值/P99

常见误区

  • 把网上的切换微秒/纳秒数字直接写进设计结论:硬件与版本差异大,应以实测为准。
  • 只测切换不测并行与阻塞:纯切换基准不代表真实服务吞吐,需结合压测场景。

追问

  • 切换成本低是否意味着协程越多越好?答:不是,内存、调度队列、同步与泄漏约束数量;目标是足够支撑并发而不冗余。
  • 怎么在服务里看切换相关开销?答:结合内核线程切换计数、运行时调度指标、CPU profiling,区分内核切换与用户态调度消耗。

01.1.1.3-014 线程局部存储在协程模型下有什么问题?

一句话结论

线程级 TLS 绑定载体线程:协程被卸载再挂载到别的载体后,原线程上下文不会跟随;把请求上下文、链路标识存在线程 TLS 里会串号或丢失。

概念解释

  • 线程 TLS:按内核线程寻址,协程迁移后载体变化。
  • 协程局部上下文:需运行时提供协程级上下文(显式传参、上下文对象、运行时线程局部映射)。
  • 典型场景:链路 trace ID、请求用户、安全上下文在异步/协程间传递。

原理流程

  1. 协程在载体 A 写入线程 TLS。
  2. 阻塞卸载,恢复时挂载到载体 B。
  3. 读线程 TLS 得到 B 的值或为空,上下文断裂。

代码或图示

VT1 挂在 M1:TLS(M1)
VT1 卸载 → 挂载 M2:TLS(M2) 不含 VT1 写入的值
正确做法:上下文对象随协程显式传递

常见误区

  • 以为框架的线程局部上下文在异步链路自动透传:很多实现需显式包装任务提交,否则跨线程/协程断裂。
  • 在协程池复用载体时残留 TLS 不清:上一协程写的值被下一协程读到,造成串号。

追问

  • Go 怎么传递请求级上下文?答:context.Context 显式逐级传递,不依赖线程局部存储。
  • Java 虚拟线程下 ThreadLocal 有什么注意点?答:挂载载体变化,ThreadLocal 不随虚拟线程迁移;重上下文场景应避免依赖线程局部,按运行时文档评估。

01.1.1.3-015 协程栈回溯和调试有什么特殊之处?

一句话结论

协程栈是独立保存的,调试器默认只看到载体线程的内核栈;要查看协程调用链需运行时提供的剖面/调试接口,跨挂载点的挂起状态也需要专门展示。

概念解释

  • 内核视角:只看到载体线程在运行时调度器里,看不到业务协程帧。
  • 运行时视角:工具导出每个协程的栈、状态、等待点与归属。
  • 断点:在协程代码里打断点命中时,当前挂载载体持有该协程栈;其他挂起协程需用工具枚举。

原理流程

  1. 调试器附加到进程。
  2. 枚举载体线程只能看到调度层栈。
  3. 调用运行时工具导出协程列表与各自业务栈。

代码或图示

线程栈(内核可见):运行时调度器帧
协程栈(运行时导出):业务函数 A → B → C(等待点)

常见误区

  • 用 gdb 看线程栈就认为协程没有业务帧:业务帧在协程独立栈,gdb 默认不展开。
  • 以为所有协程都能在断点处同步观察:挂起协程不在任何载体上,需剖面导出。

追问

  • 生产环境怎么看协程调用链?答:运行时 pprof/诊断接口导出 goroutine/虚拟线程剖面,按等待点归类。
  • 异步挂起点的栈帧为什么可能“不完整”?答:卸载时保存的是挂起点上下文,恢复后继续;工具需区分“正在运行”与“挂起等待”两种状态。

01.1.1.3-016 协程调度点(检查点)一般插在哪些位置?

一句话结论

调度点通常出现在函数调用前后、循环回边、阻塞等待原语与运行时 API 处;运行时在这些位置检查是否需要让出、抢占或处理信号。

概念解释

  • 让出点:等待通道/IO/锁、显式 yield。
  • 抢占检查点:函数序言、循环头部;运行时标记需调度后在最近检查点处理。
  • 纯计算 tight loop 内部若无检查点,抢占只能依赖信号或下一个函数调用兜底。

原理流程

  1. 协程执行到检查点。
  2. 运行时检查状态:是否阻塞、是否超时、是否有更高优先级任务。
  3. 需要切换则保存上下文,否则继续执行。

代码或图示

函数入口 / 循环回边 / await · channel · lock / 运行时调用
  → 检查调度标志 → 让出或继续

常见误区

  • 以为任意指令间都能被调度:检查点之外,协程不会被切走。
  • 以为长循环一定会在内部被抢占:取决于运行时是否在回边插入检查,纯紧循环需关注。

追问

  • 编译期怎么插入检查点?答:运行时/编译器在函数与循环位置埋入栈边界与调度检查;具体实现属于语言运行时内部。
  • 检查点太多有什么代价?答:每次检查有少量指令开销;太少则响应延迟,运行时在二者间平衡。

01.1.1.3-017 协程模型下的消息传递与共享内存怎么取舍?

一句话结论

协程推崇通过通道/消息传递在协程间移交数据所有权,减少共享可变状态;需要共享时仍用互斥原语保护;模型选择影响并发安全与调试复杂度。

概念解释

  • 消息传递:数据随消息发送,接收方拥有所有权,天然避免竞争。
  • 共享内存:多协程读写同一状态,必须加锁/原子操作保护。
  • 设计:边界处用通道解耦,内部细粒度状态用锁;避免跨协程泄露可变引用。

原理流程

  1. 生产者协程把数据封入消息发到通道。
  2. 消费者接收并获得数据所有权。
  3. 必须共享的状态由锁/原子原语保护,临界区尽量短。

代码或图示

消息传递:G1 ── channel(data) ──> G2(所有权移交)
共享内存:共享状态 + 互斥锁/原子操作

常见误区

  • 用了通道就完全不需要锁:多个消费者聚合到同一状态时仍有竞争。
  • 把可变对象引用到处传递:看似消息传递,实际共享引用,仍有并发修改风险。

追问

  • 通道本身有缓冲与阻塞语义,怎么背压?答:无缓冲同步交接;有缓冲队列积压反压生产者;满时阻塞或丢弃策略按业务定。
  • 协程间传大数据要拷贝吗?答:按语言语义,值传递拷贝、引用传递共享;设计上明确所有权,避免隐式共享。

01.1.1.3-018 什么时候该用协程,什么时候继续用线程?

一句话结论

IO 密集、并发等待多、需要大量轻量执行单元时选协程;CPU 密集、需要强隔离或阻塞语义直接、生态依赖线程模型时用线程;选型应压测对比并发量、延迟与故障模式。

概念解释

  • 协程优势:高并发等待、轻量创建、同步写法;代价是运行时约束、调试与上下文传递特殊。
  • 线程优势:模型简单直接、生态成熟、隔离性好;代价是栈内存与切换成本。
  • 混合:主服务协程化,CPU 重活放线程池/进程隔离。

原理流程

  1. 判断负载:IO 等待占比、并行计算占比。
  2. 评估生态:库是否异步友好、上下文传递与监控是否支持。
  3. 压测对比并发上限、P99 延迟、内存与故障行为后定稿。

代码或图示

IO 密集 / 海量等待  → 协程
CPU 密集 / 强隔离   → 线程/进程
混合:协程主链路 + 线程池卸载重计算

常见误区

  • 把协程当万能性能银弹:CPU 密集场景协程不减少计算量,只影响调度形态。
  • 忽视运行时成熟度:协程生态在调试、 profiling、库兼容上可能有坑,需提前验证。

追问

  • 线程池和协程池可以共存吗?答:可以,按任务类型分池;边界上注意上下文传递与阻塞隔离。
  • 选型时必须实测哪些指标?答:并发连接/任务数、吞吐、P50/P99 延迟、内存峰值、载体/线程数、阻塞点分布与故障恢复行为。