2026-11-20 AI Agent 面试训练
今日学习主题
**保证只在它所在的那一层成立。**HTTP/2 的多路复用把”一次只能处理一个请求”从应用层移走,但 TCP 的丢包恢复仍然让整条连接一起停摆——协议自己在引言里写明了”TCP head-of-line blocking is not addressed by this protocol”;OAuth 的 scope 描述”能做什么”,却完全不描述”能对谁做”,于是 token 的接收方成了没人校验的空白;一次全量评测只保证”跑完那一刻的快照”,跨不过代码变更与数据漂移;preload 省内存的前提是子进程从不写父进程建立的那片内存与那些文件描述符,而 Python 的引用计数几乎每次访问都在写。五处失效的共同结构是:把上一层成立的性质当成全局性质,于是省掉了本该在本层做的那次校验或那次重建。修正方式都落在同一处——在承诺生效的那一层显式加一个判据:连接层用独立流、协议层用 audience、工程层用影响面路由、进程层用 pid 判据。
题目目录
- B01(基础·非 Agent):HTTP/2 多路复用与 HTTP/3——队头阻塞到底被解决了哪一半
- B02(基础·Agent):MCP 授权硬化——为什么 scope 够用、而 audience 才是命门
- S01(场景·Agent):评测要跑 6 小时、发布等不起——把评测当 CI 系统做影响面路由与分级门禁
- S02(场景·非 Agent):preload 之后偶发协议错乱——fork 继承的连接、写时复制与内存假象
- L01(LeetCode):438. 找到字符串中所有字母异位词(medium,定长滑窗 + 计数差异)
运行记录(不入发送内容)
- 配置读取:成功,版本 9(
last_maintained: 2026-11-16),v9 生效后第 5 次每日出题;无暂停类型;观察中的新技术 8 项均未标记”允许试学”,未从中出题。目标目录与父目录仍无AGENTS.md/CLAUDE.md。运行前确认当日文件不存在。 - 历史来源:
题目索引.md(160 条 /indexed_runs: 30/last_updated: 2026-11-19)+精选/README.md(4 条)+ 近 30 天题目行 +README.md导航;未通读更早正文。 - 去重:窗口 2026-08-20 至 2026-11-20,窗口内最早条目 2026-10-10,无需剪除。
- L01 代码验证:官方 2 示例 + 5 自建用例 + 3000 组随机对拍(对照
Counter切片暴力实现)通过;30000 字符压力用例 0.013 s。 - 已核验来源:LeetCode 438 官方题目页(两示例、约束
1 <= s.length, p.length <= 3 * 104、小写字母、接受率 54.8%;难度标签未渲染,medium 按标准分类记录并在题内标注);RFC 9113 §1(“TCP head-of-line blocking is not addressed by this protocol”)、§2 / §5(stream 与多路复用)、§5.1.2(SETTINGS_MAX_CONCURRENT_STREAMS逐端点、超限按PROTOCOL_ERROR或REFUSED_STREAM处理)、§5.2.1(初始流控窗口 65,535 字节)、§5.2.3(窗口小于带宽时延积则吞吐被流控限制);RFC 9114 §1.1 / §1.2 / §2(HTTP/2 多路复用对 TCP 丢包恢复不可见导致全部事务停顿、QUIC 的流级可靠性与连接级拥塞控制、每请求一条 QUIC 流、“one stream that is blocked or suffers packet loss does not prevent progress on other streams”);MCP 授权规范(最新修订:OAuth 2.1 子集、RFC 8707resource参数、RFC 9207iss校验规则表、CIMD 优先且 DCR 标记为 deprecated、token 透传 MUST NOT、RFC 9728 元数据必做);MCP 授权规范 2025-06-18 修订(“MCP servers MUST only accept tokens specifically intended for themselves” 等早期表述);man-pages 6.19fork(2)(COW 实现、fd 复制后共享同一 open file description 及其文件偏移与状态标志、多线程 fork 后子进程仅剩调用线程);SQLAlchemy 2.0 Connection Pooling 文档(池化连接”are not shared to a forked process”、Engine.dispose(close=False)在子进程初始化阶段替换连接池);SWE-bench(arXiv:2310.06770 摘要:2,294 个真实 GitHub issue/PR 任务、跨 12 个 Python 仓库、发表时最佳模型解决率 1.96%)。 - 未核验:LeetCode 438 官方题解正文与难度标签渲染、中文站题名;RFC 9207 / RFC 8707 / RFC 9728 原文(语义取自 MCP 规范转述,未逐条打开 RFC 正文);QPACK(RFC 9204)与 HPACK(RFC 7541)正文;gunicorn 文档(
docs.gunicorn.org两次 404,题内不引用其配置项语义,仅按通用 preload 模式描述);jemalloc与 Python arena 调参的官方建议;LeetCode 567 题号与难度(延伸学习已标注未核验)。
B01 HTTP/2 多路复用与 HTTP/3:队头阻塞到底被解决了哪一半
- 题目 ID:
Q-20261120-B01 - 编号:B01(非 AI Agent 基础题)
- 一级类型:操作系统与网络;二级主题:HTTP/2 多路复用、TCP 层队头阻塞与 HTTP/3 的边界
- 难度:基础题(中高)
- 考察点:应用层队头阻塞与传输层队头阻塞的区别;stream 并发上限、流控窗口与连接级拥塞控制这三种真实约束;HTTP/3 把复用下沉到 QUIC 后解决了什么、没有解决什么;HTTP/3 的部署代价与适用边界。
题目
面试官问:“HTTP/1.1 用多个 TCP 连接并行发请求,HTTP/2 改成一条连接上多路复用,HTTP/3 又换成 QUIC。请说明这三步各自解决了什么问题、没有解决什么问题。如果我说’HTTP/2 已经解决了队头阻塞’,你会怎么纠正我?另外,内网服务之间要不要上 HTTP/3?”
先思考
先不要背协议特性清单,先问三个问题:(1)“队头阻塞”发生在哪一层——是应用层没法交错发送,还是传输层无法把后面的数据先交付?(2)一条连接上同时跑 100 个请求时,实际上限制并发数的是什么参数、限制吞吐的又是什么参数?(3)把 TCP 换成 QUIC,改动的是应用层语义还是传输层语义?如果只换了传输层,哪些成本会转移而不是消失?
参考答案
结论:HTTP/2 解决的是应用层队头阻塞(一条连接可以被多个请求交错使用),没有解决传输层队头阻塞;HTTP/3 把复用下沉到 QUIC,让丢包只阻塞受影响的那条流,代价是把可靠传输、拥塞控制和 TLS 都搬进用户态,并引入 UDP 可达性与 0-RTT 重放两类新问题。
定义与边界。HTTP/1.1 的一条连接在同一时刻只有一个响应在传,要并行就得开多条连接,而多条连接各自独立做拥塞控制,互相争抢、效率低(RFC 9114 §1.1 对此有明确批评)。HTTP/2 引入 stream:一条 TCP 连接上多个 stream 交错发送帧,每个请求/响应对应一条 stream,“streams are largely independent of each other”,这是应用层的解耦。但 RFC 9113 的引言把边界写得毫不含糊:“Note, however, that TCP head-of-line blocking is not addressed by this protocol.” 原因是 TCP 把一个字节流按序交付,只要有一个段丢失,后面已到达的字节也不能交给上层——而 HTTP/2 的多路复用对 TCP 的丢包恢复机制是不可见的,RFC 9114 §1.1 的表述是”a lost or reordered packet causes all active transactions to experience a stall regardless of whether that transaction was directly impacted”。HTTP/3 的做法是把可靠性从”整条连接一个序”改成”每条流一个序”:QUIC 提供流级可靠性与流级流控,拥塞控制仍在连接级,TLS 1.3 集成在传输层,因此”one stream that is blocked or suffers packet loss does not prevent progress on other streams”。
**一个具体示例。**一条 HTTP/2 连接上有 100 条活跃 stream,客户端在传一个大文件(stream 1)同时轮询 99 个小接口。某个 TCP 段在链路上丢了:在 RTO 或快速重传完成之前,内核不会把后续字节交付给 HTTP/2 层,于是 99 个小接口的响应一起被扣住,即使它们的帧早已到达。换成 HTTP/3,这 100 个请求各占一条 QUIC 流,丢包只让 stream 1 等待重传,其余 99 条照常交付。反过来说,如果瓶颈是带宽而不是丢包,QUIC 也救不了:连接级拥塞控制是共享的,一条流占满带宽时其他流一样变慢。
相近概念的区别。(1)与”多开连接”的区别:多开连接能绕开 TCP 层队头阻塞,但代价是拥塞控制各自为政、握手与内存成本线性增长,而且服务端的连接数与 TLS 握手开销会先撑不住。(2)与 HTTP/1.1 pipelining 的区别:pipelining 只是把请求排进管道,响应仍须按序返回,应用层队头阻塞没有消除,实践中基本被禁用。(3)与 WebSocket 的区别:WebSocket 是升级后的双向消息通道,单连接单语义,不提供请求级复用。(4)与 gRPC 的区别:gRPC 是跑在 HTTP/2 上的 RPC 框架,它继承 HTTP/2 的复用能力,也继承 TCP 层队头阻塞。
**真实约束(这部分最容易被跳过)。**多路复用不等于无限并发:并发流上限由 SETTINGS_MAX_CONCURRENT_STREAMS 逐端点协商,超限时对端必须按 stream error 处理(PROTOCOL_ERROR 或 REFUSED_STREAM);每条流与整条连接还有基于信用的流控窗口,初始值 65,535 字节,需要 WINDOW_UPDATE 补充;RFC 9113 §5.2.3 明确指出,如果接收方无法保证对端始终有大于带宽时延积(BDP)的可用窗口,吞吐就会被流控卡住——高延迟高带宽链路上”HTTP/2 比 HTTP/1.1 慢”的经典事故,多半是窗口没调而不是协议不行。还有一个易被忽略的运营约束:一条连接是单点,一旦它被中间设备空闲超时或 NAT 表项回收,上面的所有流一起断。
**典型应用。**通用工程里,HTTP/2 适合”大量小请求 + 服务端推送收益不明显”的场景(网关聚合、移动端 API、gRPC 微服务),HTTP/3 在弱网、高丢包、移动网络切换(QUIC 的连接迁移用 connection ID 而不是四元组)场景收益最明显;同一机房内网、丢包率极低、链路可控时,HTTP/3 的收益接近于零,而 UDP 在部分网络策略下被限速或被中间设备直接丢弃,运维与可观测成本反而上升。所以内网服务间调用的默认答案仍是 HTTP/2 + 连接复用 + 窗口与并发调优,HTTP/3 留给”客户端在公网、链路质量不可控”的那一侧。
**常见误区。**第一,把”HTTP/2 解决了队头阻塞”当成完整结论——它只解决了应用层那一半。第二,把 HTTP/3 当成”更快的 HTTP/2”——它换的是传输层,在高带宽低丢包网络里的收益很小,且 0-RTT 恢复数据存在重放风险,非幂等请求不能放进 0-RTT。第三,认为多路复用可以让一条连接承担任意并发——流数、流控窗口、连接级拥塞控制、单连接故障域四重约束都在。
面试现场怎么答(1–2 分钟):“HTTP/1.1 的问题是一条连接同时只能有一个响应在传,并行要靠多连接,代价是拥塞控制各自为政。HTTP/2 在一条 TCP 连接上做 stream 复用,解决了应用层队头阻塞,但 RFC 9113 自己写了 TCP 层队头阻塞没被解决——一个段丢了,所有流一起等重传,因为多路复用对 TCP 的重传机制不可见。HTTP/3 把复用下沉到 QUIC,每条流独立有序,丢包只影响那条流,同时把 TLS 1.3 集成进传输层、支持连接迁移;代价是可靠传输与拥塞控制进了用户态,UDP 可能被限速,0-RTT 有重放风险。所以’HTTP/2 解决了队头阻塞’这句话只对一半:它解决了应用层,没解决传输层。内网低丢包场景我不会上 HTTP/3,收益比不上运维复杂度。”
关键点
- 队头阻塞要分两层说:应用层(HTTP/1.1 一次一个响应)与传输层(TCP 按整条连接有序交付);HTTP/2 只解决前者,且 RFC 9113 原文承认这一点。
- 多路复用受三个量约束:
SETTINGS_MAX_CONCURRENT_STREAMS(流数)、流控窗口(初始 65,535 字节,需WINDOW_UPDATE)、连接级拥塞控制(带宽共享)。 - HTTP/3 的收益来自”流级有序 + 连接迁移 + 传输层集成 TLS 1.3”,不是”协议更新所以更快”。
- 0-RTT 数据可被重放,非幂等请求必须等 1-RTT 握手完成。
- 一条连接是单点故障域:连接被中间设备回收会让所有流一起失败,连接层的韧性不能靠”复用得更狠”。
常见误区
- “HTTP/2 彻底解决了队头阻塞。” 错。它只消除了应用层阻塞,TCP 丢包仍会阻塞整条连接上的所有流,这是 RFC 9113 明确写出的未解决问题。
- “HTTP/3 一定比 HTTP/2 快。” 错。收益与丢包率强相关;低丢包高带宽链路上收益趋零,而 UDP 被 QoS 限速、中间设备阻断、可观测工具缺失会带来净损失。
- “一条连接并发流越多越好。” 错。并发流数受协商上限约束,吞吐受流控窗口与 BDP 约束,过量并发只是把排队从客户端挪到服务端。
延伸学习
- RFC 9113《HTTP/2》,重点读 §1 Introduction 最后一段(承认 TCP 队头阻塞未解决)与 §5.1.2、§5.2.1、§5.2.3(流并发、流控初始窗口、流控对吞吐的限制):https://www.rfc-editor.org/rfc/rfc9113.html
- RFC 9114《HTTP/3》,重点读 §1.1(HTTP/1.1 与 HTTP/2 的队头阻塞成因)、§1.2(委托给 QUIC)、§2(每请求一条 QUIC 流):https://www.rfc-editor.org/rfc/rfc9114.html
追问
追问 1:为什么不能直接在 UDP 上跑 HTTP/2 的帧,而要大改一版 HTTP/3? 回答要点:HTTP/2 的可靠性、按序交付、拥塞控制全部寄生在 TCP 上,UDP 不提供这些;把帧层搬到 UDP 上等于要在应用层重建可靠传输与拥塞控制,而那正是 QUIC 做的事,干脆做成通用传输层。另外 HTTP/2 的头部压缩 HPACK 依赖”整条连接共享一张动态表且严格按序更新”,在会出现乱序交付的传输上会阻塞解码,所以 HTTP/3 改用 QPACK 并对动态表更新做显式同步(HPACK/QPACK 正文本轮未核验,结论按协议设计动机表述)。
追问 2:线上观察到 HTTP/2 网关的 p99 比 HTTP/1.1 还差,你会先查什么?
回答要点:先分清是”排队”还是”阻塞”。查单连接上活跃流数与 SETTINGS_MAX_CONCURRENT_STREAMS 是否被打满、流控窗口是否长期触底(窗口耗尽时吞吐被 BDP 限制,表现为高延迟链路上的”慢而稳”)、是否所有请求集中在少数几条连接上(客户端连接池按 origin 复用会把多路复用变成新的热点)、以及是否有一个大响应流把连接级带宽吃光。最后才怀疑丢包导致的传输层阻塞——这一项要靠 TCP 重传率与 RTT 分布确认。
追问 3:如果必须让内网 gRPC 服务也吃到”丢包只影响一条流”的好处,你有哪些不动协议的选择? 回答要点:先用工程手段压低单点影响面——把大响应拆成多条连接或独立流并设置 per-stream 超时、对长尾请求做 hedged request、把大文件传输从 RPC 通道挪到对象存储直传(避免大流挤占共享拥塞窗口)。真要做传输层替换,是引入支持 HTTP/3 的 sidecar 与负载均衡,属于平台级改造,要同时准备 UDP 放通、指标采集与回退开关。
B02 MCP 授权硬化:为什么 scope 够用、而 audience 才是命门
- 题目 ID:
Q-20261120-B02 - 编号:B02(AI Agent 基础题)
- 一级类型:工具与互操作协议;二级主题:MCP 授权硬化(资源绑定、发行方校验与客户端注册收敛)
- 难度:基础题(中高)
- 考察点:MCP 远程传输授权的标准构成与 MUST 边界;
resource/audience 绑定解决的”token 拿错对象”问题;iss校验的比较规则与失败行为;DCR 被 CIMD 取代后的注册路径与迁移选择;token 透传禁止背后的混淆代理结构。
题目
面试官问:“你把公司内部的几个 MCP 服务开放给了第三方 Agent 平台,走 OAuth。安全评审提了三条:token 必须绑定接收方、必须校验发行方、不能再依赖动态客户端注册。请解释这三条各自防的是什么攻击,协议里对应的机制是什么,以及如果你只做 scope 校验会发生什么。再告诉我,MCP 服务调用上游 SaaS 时,能不能把客户端给的 token 直接转发过去。”
先思考
先想清楚三件事:(1)一个 token 里哪几个字段决定”它能被谁用”、哪几个决定”它能做什么”——如果只有后者,持有者可以把它用到哪里?(2)客户端从授权服务器拿到授权码后,凭什么确认这个响应真的来自它发现的那台授权服务器?(3)MCP 服务是”资源服务器”还是”客户端”?当它去调上游 API 时,它换成哪个身份?
参考答案
结论:scope 只界定权限维度、不界定接收方,所以必须用 RFC 8707 的 resource 参数把 token 绑定到具体 MCP 服务并在服务端校验 audience;iss 校验防的是”授权响应被换成另一台授权服务器签发”;DCR 的退场是因为它让任何人都能自助注册 client,收敛到 Client ID Metadata Documents 后 client 的身份有可验证的宿主;token 透传必须禁止,否则 MCP 服务就成了把用户凭证带进上游系统的混淆代理。
**定义与适用边界。**MCP 的授权机制是 OAuth 2.1 的一个受限子集,规范明确”authorization servers MUST implement OAuth 2.1 with appropriate security measures for both confidential and public clients”。角色上,MCP 服务是 Resource Server,必须用 RFC 9728(Protected Resource Metadata)暴露”我的授权服务器是谁”,客户端必须用这份元数据做发现。授权本身是 OPTIONAL:STDIO 传输的实现 SHOULD NOT 走 OAuth,而应从环境取凭证——这一点常被忽略,本地工具进程套 OAuth 流程往往是把安全问题搬到了不该有的地方。
三条硬化的机制与它防的攻击。
第一条,接收方绑定。客户端在授权请求与 token 请求中都必须带 resource(RFC 8707 的规范 URI),服务端必须校验”这个 token 是专门发给我用的”,不接受 audience 不含自己的 token。防的是什么:token 混淆与横向移动——攻击者拿到一个发给 A 服务的 token,直接拿去调 B 服务;如果 B 只校验签名和 scope,而两个服务的 scope 名字恰好一样(read、tools:invoke 这类粗粒度命名极常见),B 就会照单执行。这也是为什么”只做 scope 校验”不够:scope 是权限集合,audience 是主体,二者正交。
第二条,发行方校验。这里的关键不是”校验签名”,而是”校验这个授权响应来自我预期的那台授权服务器”。混合攻击(mix-up)的形态是:客户端同时在和多个授权服务器打交道,攻击者诱导它把 A 的授权码交给 B 的 token 端点,或把 B 签发的 token 当成 A 的。规范的做法是客户端在发起流程时把已验证元数据里的 issuer 记进本次请求的上下文(与 PKCE 的 code_verifier、state 同一条记录),收到授权响应时按 RFC 9207 §2.4 校验 iss:必须做简单字符串比较,不得做大小写折叠、默认端口省略、去尾斜杠或百分号解码归一化;元数据声明 authorization_response_iss_parameter_supported = true 而响应里缺 iss 时,客户端必须拒绝该响应;校验失败时连 error、error_description、error_uri 都不能显示或依据其行动(否则错误字段本身成了注入面)。规范同时说明这是一条会收紧的要求:iss 目前是 SHOULD,未来修订预计升为 MUST。
第三条,注册路径收敛。最新修订把 Client ID Metadata Documents(CIMD)列为 SHOULD 支持的首选,DCR(RFC 7591)降为 MAY 且被明确标注 deprecated、仅为兼容旧授权服务器保留。原因不难推:DCR 允许任意客户端自助拿到 client_id,授权服务器无法在注册时判断对方是谁,于是”谁能代表某个 Agent 平台”这件事在协议层没有答案;CIMD 用 HTTPS URL 作为 client_id,客户端元数据托管在自己的域名下,身份校验退化为”这个 URL 的宿主是谁”,可验证、可撤销、可审计。迁移期要同时准备三条路径:CIMD 优先、预注册兜底、DCR 仅对已知旧对端开启并登记。
一个具体示例。第三方 Agent 平台接入你的 ticket-mcp。攻击者自建一台授权服务器,用自己的密钥给受害者签发一个 scope=read tools:invoke、aud=https://ticket-mcp.internal 的 token——注意这里 audience 也被伪造了,所以光校验 audience 不够,还必须校验签发者:ticket-mcp 只接受元数据里声明的那台企业 IdP 签发的 token(issuer 与签名密钥都来自该 IdP 的 JWKS)。两条一起才闭合:audience 防”发给别人的 token 用在我这”,issuer 防”别人冒充我的授权服务器发 token”。
与相近概念的区别。(1)与 scope 的区别:scope 是”能做哪些动作”,audience 是”能对谁做”,issuer 是”谁担保的”。(2)与 API key 的区别:API key 通常是长期、无 audience 概念的共享密钥,无法表达”为某用户、对某服务、在某时段”。(3)与 mTLS 的区别:mTLS 认证的是连接两端,不表达用户授权与权限范围,二者常叠加而非替代。(4)与代持令牌(delegation,sub/act)的区别:那是”Agent 代表用户行事”的身份链表达,本题是”凭证只能对某个资源生效”的绑定关系,二者正交,一个完整的 Agent 授权体系两者都要。
典型应用(Agent 系统里它意味着什么)。MCP 服务是 Agent 能力的边界:Agent 会把工具输出、甚至工具凭证当作可编排的素材,一旦 token 不绑定接收方,模型完全可能(或被诱导)把它用到另一个工具上——这不是”模型不听话”,而是凭证设计允许了这种用法。因此 audience 绑定与 token 透传禁止,本质上是把”凭证的作用域”从提示词里的约束变成协议层的强制,属于确定性系统承担责任、而不是让模型自律的那一类设计。同时它直接改善审计归因:日志里 (issuer, audience, sub, act) 四元组能回答”谁的凭证、被谁担保、对哪个服务、代表谁”。
**常见误区。**第一,认为 scope 粒度做细就够了——scope 再细也不表达接收方。第二,把 iss 比较实现成 URL 归一化后比较,看似更宽容,实际打开了”看起来相同”的绕过口(规范要求简单字符串比较)。第三,把 DCR 当成标准做法继续新建集成——它已是 deprecated 的兼容路径。第四,让 MCP 服务把客户端 token 透传给上游 SaaS——规范对此是 MUST NOT,且它会把下游系统拖进同一个信任域。
面试现场怎么答(1–2 分钟):“MCP 远程授权是 OAuth 2.1 的受限子集,MCP 服务是资源服务器。第一条硬化是 audience 绑定:客户端必须带 RFC 8707 的 resource,服务端必须拒绝 audience 不含自己的 token——因为 scope 只说明能做什么,不说明能对谁做,粗粒度 scope 命名下横向移动几乎无成本。第二条是 issuer 校验:客户端把发现阶段验证过的 issuer 记进本次请求,按 RFC 9207 校验响应里的 iss,且必须简单字符串比较,不做 URL 归一化;校验失败时连错误字段都不能信。第三条是注册路径:CIMD 优先,DCR 已经 deprecated,只作为旧对端兼容。最后一条底线是 MCP 服务不得透传客户端 token 给上游,否则它就成了混淆代理,上游系统会把这份凭证当成合法授权。”
关键点
scope(能做什么)、audience(对谁做)、issuer(谁担保)三者正交,缺任一都可被利用。- audience 校验必须发生在资源服务器侧,且必须是”拒绝”而不是”记录后放行”;携带必须是每个 HTTP 请求都带 Bearer 头,不得放进查询串。
iss比较是简单字符串比较,禁止 URL 归一化;元数据声明支持但响应缺iss时必须拒绝;校验失败时不得依据错误字段行动。- CIMD 取代 DCR 的本质是把”客户端身份”从自助声明变成可验证的宿主声明;迁移期三条注册路径要显式登记。
- token 透传 MUST NOT:MCP 服务的上游调用必须使用上游授权服务器单独签发的凭证。
常见误区
- “我们 scope 分得很细,所以不用管 audience。” 错。scope 描述动作集合,不描述接收方;跨服务同名 scope 会让 token 直接可用。
- “校验了签名就等于校验了发行方。” 错。签名只证明”某把密钥签的”,必须把这把密钥绑定到元数据里声明的那台授权服务器(issuer + JWKS 来源),否则攻击者自建授权服务器同样能签出合法签名的 token。
- “客户端注册随便放开,反正有用户同意。” 错。DCR 让 client 身份不可验证,用户同意界面展示的是不可信的自述信息;这正是 CIMD 要收敛的问题。
延伸学习
- MCP 规范 Authorization(最新修订):重点读 Standards Compliance 列表、Overview 中关于 CIMD / DCR 的 SHOULD 与 deprecated 表述、Authorization Response Validation 的
iss判定表与”不得归一化”要求:https://modelcontextprotocol.io/specification/latest/basic/authorization - MCP 规范 Authorization(2025-06-18 修订):用于对照早期表述,特别是”MCP servers MUST only accept tokens specifically intended for themselves”与 token passthrough 的 MUST NOT:https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization
追问
追问 1:企业内网有 40 个 MCP 服务、一台统一网关负责签发,怎么既复用凭证又不放弃 audience 绑定?
回答要点:audience 的粒度由签发决定,不由网关决定——网关按每个 MCP 服务的标识(RFC 8707 的规范 URI)分别签发 token,或者在 token 请求时把 resource 作为参数、由授权服务器按 resource 签发。不能”签一个通吃的 token 再在网关上做映射”,那等于把 audience 校验退化成了网关的字符串匹配,一旦绕过网关(服务直连、内网横向)就失效。如果确实需要减少签发次数,做法是短 TTL + 按需换取(token exchange),而不是放宽 audience。
追问 2:iss 已是 SHOULD,我们暂时不校验,风险有多大?
回答要点:风险大小取决于”客户端是否同时对接多个授权服务器”。单 AS 环境下 iss 缺失的收益确实小,但两个前提必须成立:token 端点的归属由已验证元数据确定、并且客户端对授权响应做过 state 与 PKCE 绑定。多 AS 环境(第三方 Agent 平台接多家客户 IdP 是常态)下不校验 iss 就等于允许混合攻击,且这类攻击的表现是”登录成功但身份错了”,从日志上极难发现。工程上的折中是:先按规范实现判定表但只告警,同时推动对端在元数据里声明支持,达到覆盖率后再切拒绝。
追问 3:MCP 服务要访问上游 SaaS,为什么不能让上游信任我们收到的这份 token? 回答要点:因为上游无法区分”这份 token 是用户授权给这个 MCP 服务的”还是”用户授权给上游的”——信任它等于把上游的授权判定外包给了一个它不认识的签发者,这就是混淆代理。正确做法是 MCP 服务用自己的身份(client credentials 或独立注册的 client)去上游换一份受众为上游的 token,并在自己的审计里记录”用户 → MCP 服务 → 上游”的链条;如果上游支持 token exchange,则用受控的交换流程并保留 subject。
S01 评测要跑 6 小时、发布等不起:把评测当 CI 系统做影响面路由与分级门禁
- 题目 ID:
Q-20261120-S01 - 编号:S01(AI Agent 场景题)
- 一级类型:Agent 评测与可观测性;二级主题:评测体系工程化(影响面路由、分级门禁与评测成本)
- 难度:场景题(高)
- 核心考点:把评测当”测量系统 + CI 流水线”设计而非一次性脚本;变更类型到受影响用例集的映射;覆盖率、反馈时延与成本的三方取舍;门禁分级与豁免留痕;评测自身的幂等与可复现。
题目
**业务背景。**一家做 B 端客服与工单处理的 SaaS,Agent 负责三件事:回答产品与计费问题、按模板创建工单、对账单项做分类与优先级判定。团队 12 人,每周大约 15 次变更:提示词调整、工具定义与参数 schema 改动、检索配置、模型版本升级(三档模型:小模型做分类、中模型做问答、大模型做复杂工单)。
**系统规模。**日活坐席 4000,Agent 日均处理 26 万次会话、4.1 万次工单创建;评测集 420 条人工构造用例,另有线上抽样回流池约 5000 条未标注轨迹;判分以确定性断言为主,约 30% 需要 LLM judge 打分。
**当前架构与数据流。**变更合并后由 CI 触发一个 run_evals.py:起 8 个并发 worker,逐条跑 420 个用例(每条要真实调用检索与工具,工具走 staging 沙箱),结束时把结果写成一份 JSON 报告贴到 PR 上。全量一次 6.2 小时,judge 成本约 380 美元/次,且因为工具沙箱偶发超时,报告里常有 3%–6% 的用例处于”未完成”状态。
**目标。**每次变更在 40 分钟内给出”能不能发”的判定;判定结果要能被非评测同学读懂;回归不能比现在更容易逃逸。
**限制条件。**标注人力每月 200 条预算;judge 只能调用外部模型 API(数据出站需走合规审批);PR 合并时段集中在下午 14:00–18:00,评测队列会排队;不允许为评测单独维护一套与线上不同的工具实现(避免”评测通过、线上下线”的两套语义)。
已知现象。
- 过去六周有 3 次线上回归:一次是工单模板必填字段被改后小模型输出少字段、一次是检索配置调整导致计费类问题引用旧条款、一次是工具参数校验放宽后把”优先级=高”错判成”中”。
- 这三次回归里,有两次对应的 PR 是”评测还在跑就先合了”——因为 6.2 小时挡住了发布窗口。
- 团队开始出现”评测挂着、先上”的默认操作,PR 上贴着”评测 pending”的合并已成常态。
- 有同学反馈,即使跑完,报告也只是”通过率 91%“,没人知道 91% 里少了哪一块。
**需要取舍的问题。**在标注预算与 judge 成本都不变的条件下,如何同时拿到”40 分钟内的可判定结论”与”不比现在更差的回归捕获能力”?请给出评测体系的设计,并说明当变更类型无法归类时你的默认策略。
先思考
先不要急着做”抽样跑一部分用例”,先回答三个问题:(1)那 420 条用例是均匀有价值的吗——哪一类变更会打破哪一类用例,这个映射现在存在吗?(2)“未完成”的 3%–6% 应该算通过、算失败,还是算第三种状态?(3)如果要把 6.2 小时压到 40 分钟,你打算压”用例数”、“单条耗时”,还是压”等待与重跑”?这三个来源的压缩空间完全不同。
参考答案
结论:把评测从”一个脚本”改成”一条有分层、有路由、有门禁语义的流水线”。核心不是把 420 条跑得更快,而是让每次变更只跑它真正能影响到的那部分用例(影响面路由),把无法判定的用例显式升级而不是当成噪声,并用分级门禁 + 豁免留痕把”先上后补”从默认操作变成需要签字的例外。
**问题拆解。**现有体系有三个独立缺陷,混在一起才显得无解。第一,判定语义缺失:报告只有聚合通过率,没有”哪些能力必须过、哪些只是观察”,于是一次模板字段回归可以淹没在 91% 里。第二,没有影响面模型:所有变更都跑全量,等于用最贵的测量去覆盖最不可能受影响的部分,同时最该跑的那部分又被”未完成”污染。第三,流水线本身不可信:工具沙箱超时让 3%–6% 的用例处于未知态,而未知态被折叠进分母,导致同一版本两次跑的结果不可比——这会直接摧毁团队对门禁的信任,而”信任崩塌”正是”先上后补”的成因。
核心方案(四层)。
第一层,用例分层与断言分级。把 420 条按”能否确定性判定”切开:L0 是纯确定性断言(结构化输出 schema、工具名与参数、必须出现的字段、禁止出现的动作、引用必须命中白名单文档),这类不花钱、秒级;L1 是”可断言 + 需要跑工具”的功能用例;L2 是需要 judge 的开放性质量用例。同时给每条用例打两个标签:能力标签(问答 / 工单创建 / 分类定级 / 引用溯源)与风险等级(阻断 / 告警 / 仅记录)。这一步是后面所有取舍的前提——没有标签,路由和门禁都无从谈起。
第二层,影响面路由(change → capability)。维护一张版本化的映射表,把变更类型映射到能力标签:
- 工具定义或参数 schema 变更 → 依赖该工具的能力标签(如”工单创建”),并强制追加该工具的 L0 契约用例;
- 检索配置 / 索引 / 切片变更 → “问答”与”引用溯源”,强制追加引用白名单断言;
- 提示词变更 → 变更归属的 intent 桶(提示词按意图分片存放,映射由文件路径推导,不靠人填);
- 模型版本或路由变更 → 全能力标签 + 全量 L0;
- 未命中任何规则 → 走默认策略:全量 L0 + L1 + 抽样 L2(见下文”边界”)。
映射表必须是配置数据、纳入代码评审、有版本号并写进报告头。这样”这次跑了多少、为什么只跑这些”是可审计的,而不是评测同学的心算。
第三层,门禁分级与判定语义。门禁输出三态而不是两态:pass、block、inconclusive。block 只由阻断级用例的失败触发(安全类、权限类、必填字段类、引用合规类);告警级用例的失败产出”退化清单”但不阻断,要求 PR 作者逐条回应;inconclusive 专指”用例因环境原因未能判定”,它不进入分母、也不允许被折叠成通过,而是让本次判定整体降级为”不完整”,并在合并前要求补齐或在豁免记录中说明覆盖缺口。
第四层,流水线工程化。判断类工作全部前移到不需要网络的阶段:L0 与 schema 校验在 90 秒内完成,先在 PR 上给出”结构性破坏”的快速反馈;L1 用固定容器的 staging 工具,用例级超时 + 最多一次重试,并把”工具超时”与”断言失败”分成两个字段;L2 只跑受影响子集 + 上一轮失败的用例(回归池),judge 结果按 (用例指纹, judge 模型版本, 输入哈希) 做缓存,未变更输入直接复用历史判分——这一项通常能砍掉 40%–60% 的 judge 调用。全量 L2 改为夜间跑,只用于观测与趋势,不参与单次门禁。
**执行流程(一次变更的完整路径)。**PR 创建 → 解析变更文件与提交信息得到变更类型 → 查映射表得到能力标签与用例子集 → 并行跑 L0(≤90 秒)→ 结构性失败立刻 block → 跑 L1 子集(目标 ≤12 分钟,8→24 并发 + 用例级超时)→ 跑 L2 子集(judge 缓存命中优先,目标 ≤20 分钟)→ 汇总成一份”分层报告”(阻断项 / 退化清单 / 未判定项 / 覆盖声明)→ 门禁判定 → 合并。全程带 run_id,报告可回链到 run_id,线上事故复盘时能反查”当时跑了哪些、跳了哪些”。
技术选型与依据。(1)用例与断言的存储用 YAML + schema 校验,而不是数据库:变更走 PR 评审,谁改了断言一目了然;规模到几千条再迁 DB。(2)judge 缓存用内容寻址(输入哈希)而不是 (case_id, run_id):前者天然幂等、跨版本可复用,后者每次都失效。(3)并发用进程池 + 容器级资源限制,不用线程池:单条用例是 I/O 与子进程混合,线程池会把超时传播成雪崩。(4)工具侧坚持”一套实现”:staging 与线上共用同一份工具镜像,只换配置与凭证,避免”评测语义 ≠ 线上语义”。(5)报告用结构化 JSON + 渲染层,禁止脚本里直接拼字符串——报告要被门禁程序读,也要被人读。
备选方案与否决理由。备选一:只跑”最近失败用例 + 随机抽样 60 条”。它把时延压到了 15 分钟,但抽样对”模板字段被改”这类全局性破坏的检出率极低(命中率约等于受影响用例占比),三次回归里至少两次会漏,否决。备选二:把 420 条全部交给小模型预筛、只对可疑项上 judge。成本降了,但预筛本身是概率性判定,会把”看似通过”的错误答案放过,且引入了不可解释的第二层偏差,只作为 L2 内部的成本优化手段而非门禁依据。备选三:把评测搬到线上做影子流量。最真实,但无法在合并前给出判定,只能作为发布后的观测,不能替代门禁。
失败路径与恢复。(1)映射表漏项 → 表现为”逃逸率上升”,恢复靠每周用线上失败样本反查:把最近一周的线上失败轨迹按能力标签回填进映射表,并把该条加入回归池。(2)judge 版本被上游静默升级 → 判分分布整体偏移,表现为”同一版本的通过率跳变”,恢复靠 judge 模型版本 pin + 输入哈希里包含版本号 + 每周 20 条人工标定,偏移超阈值时冻结 judge 并回退版本。(3)沙箱不稳定 → 未判定项飙升,恢复靠”工具健康探测在前、用例执行在后”,探测失败直接把本次判定置为 inconclusive 并要求修复环境,绝不带着高未判定率出结论。(4)评测队列拥塞 → 恢复靠优先级队列(阻断级变更插队)+ 变更合并(同文件多 PR 合并为一次评测 run)+ 把 L2 全量推到夜间。
**边界条件与超时策略。**单条用例硬超时(L1 90 秒 / L2 180 秒),超时记为 inconclusive 而非失败;run 级总超时 50 分钟,超时后输出”部分结论 + 覆盖声明”,禁止默默截断;同一 PR 的新 commit 取消旧 run(run_id 版本比较),避免旧结果覆盖新结果;紧急修复通道只允许跑 L0 + L1 且必须在 24 小时内补全量,补跑结果挂回同一 PR。
重试与幂等。评测任务以 (run_id, case_id) 为幂等键,重跑只补未完成项,已判定的不重判(除 judge 版本变化)。工具调用在评测中必须使用只读或沙箱账号,所有写操作打到隔离库;若某条用例本质需要写,用”请求指纹”做去重,保证重试不产生第二次副作用。产物(报告、轨迹)以 run_id 命名并设 TTL,避免存储无界增长。
**安全、成本、延迟、可靠性。**安全:评测数据含真实工单片段,需在入库时脱敏并做访问控制;judge 调用属数据出站,需按合规审批走白名单模型与最小字段(只发改写后的用例输入,不发原始轨迹全量)。成本:judge 预算按”受影响子集 × 缓存命中率”重新估算,把省下的钱用于每周 20 条人工标定——这是维持 judge 可信度的必要开销。延迟:90 秒 / 12 分钟 / 20 分钟三段,任何一段超时都降级为”部分结论”而不是”静默等待”。可靠性:评测系统本身要能挂——评测不可用时门禁默认 block(fail-closed),而不是默认放行。
评测指标与观测方式。(1)反馈时延:p50 / p95 从 PR 创建到判定产出,目标 p95 ≤ 40 分钟。(2)逃逸率:上线后 7 天内归因为”评测未覆盖或未阻断”的线上失败占比,按能力标签分桶,这是唯一能证伪整套设计的指标。(3)未判定率:inconclusive 占比,目标 < 2%,超过 5% 触发环境治理。(4)门禁绕过次数与豁免清单:每次豁免记录签字人、原因、补跑结果,月度复盘。(5)judge 缓存命中率与单次成本。(6)判分一致性:每周抽 20 条做人工标注,算与 judge 的一致率,低于阈值即冻结 judge。
**能力归属要分清。**模型能力决定”答案本身对不对”(这只能被测,不能被流水线创造);Agent 编排决定”用例怎么被执行、失败怎么分类、重试与缓存怎么组织”(这是本题方案的主体,属于确定性可验证的工程能力);传统软件系统提供”断言、指纹、幂等键、超时、队列、门禁状态机”这些确定性保证。把三者混为一谈的典型错误,是拿”通过率”去同时解释模型退化和流水线不稳。
关键点
- 判定语义先于性能优化:没有阻断/告警/未判定三态,压到 40 分钟也只是更快地给出一个不可信的数字。
inconclusive必须是一等状态,不能折叠进分母——它折叠一次,门禁的公信力就没了,之后所有”先上后补”都是它的后果。- 影响面路由的价值来自”映射表是配置且有版本”,不来自算法;映射表必须能被线上失败样本反向修正,否则它会随时间腐化。
- judge 结果按输入哈希 + 模型版本缓存,是成本与可复现性同时改善的唯一手段;按
run_id缓存等于没缓存。 - 门禁不可用时必须 fail-closed,否则”评测挂了先上”会重新变成默认路径。
常见误区
- “抽 20% 用例跑一下就够了。” 错。随机抽样对全局性破坏(模板字段、schema 放宽、引用白名单)检出率极低,正确做法是按变更影响面定向选子集,而不是按比例抽样。
- “超时的用例算失败,逼大家修环境。” 错。把未知态算成失败会让人把注意力放在”让报告变绿”上,很快演化成调大超时或跳过用例;未知态必须独立呈现并把整体判定降级。
- “离线评测通过就代表线上没问题。” 错。评测集是有限分布的快照,线上分布会漂移。必须有”线上失败样本回流 → 补进回归池”的闭环,并用逃逸率衡量闭环是否有效。
延伸学习
- SWE-bench(arXiv:2310.06770):看它如何把”真实 issue + 对应 PR”构造成可自动判定的任务,以及为什么用测试用例作为判定而非人工打分——这是”确定性断言优先”的最直接工程范本:https://arxiv.org/abs/2310.06770
- 实践方向:把评测跑成 CI 的最小实现——先用 20 条用例写出 L0 断言 + 一张”变更文件 → 能力标签”的映射表,再对比”全量跑”与”路由跑”的时延与命中差异;这一步能在半天内验证整套设计是否成立。
追问
追问 1:映射表一定会漏。你怎么让漏项在造成线上事故之前暴露? 回答要点:把映射表当”有逃逸率的分类器”来运营,而不是当”必须完备的规范”。三条手段:一是兜底默认策略——未命中任何规则时跑全量 L0 + L1 + 抽样 L2,让漏项不至于裸奔;二是反向回流——每周把线上失败轨迹按能力标签回填映射表,并要求同类失败第二次出现时必须已有对应用例;三是覆盖率指标——统计”变更文件中未被任何规则命中的比例”,这个比例上升就是映射表腐化的早期信号。
追问 2:judge 只用于 30% 的用例,但成本占了大头。你会不会考虑用更强/更弱的 judge 混合,怎么保证可比? 回答要点:可以做混合,但必须把”判分口径”和”成本优化”分开处理。具体是:judge 模型版本参与缓存键与报告头,不同 judge 的分数不跨版本比较;弱 judge 只用于预筛(把明显通过的放行),任何”疑似失败”必须由强 judge 复判,避免弱 judge 的假阴性直接变成门禁结论;同时每周用人工标注集校准两条 judge 的一致率,任一低于阈值就停止混合。核心原则是:可以换测量工具,但不能在同一个时间序列里混用两把尺子。
追问 3:这套体系上线三个月后,你判断它是否成功的依据是什么? 回答要点:不看”评测通过率”,看三个数:逃逸率是否下降(按能力标签分桶)、p95 反馈时延是否稳定在 40 分钟内、豁免次数是否在下降。逃逸率不降说明覆盖与路由有问题;时延不稳说明队列与并发设计有问题;豁免不降说明门禁设计得比团队能力更严,需要重划阻断级别而不是继续加压。反过来,如果通过率一直 99% 而逃逸率不降,那说明用例集已经与线上分布脱节,该做的是补用例而不是庆祝。
小型实践(30–60 分钟)
挑 10 条你熟悉的 Agent 用例,做三件事:(1)给每条写一条 L0 确定性断言(schema 必填字段、工具名白名单、禁止动作),用纯 Python 跑,目标 5 秒内出结果;(2)写一张 6 行的”变更类型 → 受影响用例”映射表,故意留一行”未命中 → 全量 L0”;(3)造一个”必填字段被删”的假变更,验证 L0 是否在 5 秒内 block。做完你会对”阻断级断言应该长什么样”有一次体感,这比读十篇评测文章有用。
S02 preload 之后偶发协议错乱:fork 继承的连接、写时复制与内存假象
- 题目 ID:
Q-20261120-S02 - 编号:S02(非 AI Agent 场景题)
- 一级类型:编程语言与运行时;二级主题:fork 语义、文件描述符继承、写时复制与进程内存治理
- 难度:场景题(高)
- 核心考点:fork 后 fd 共享同一 open file description 的后果;连接池跨进程复用的失败形态;写时复制在引用计数语言里的收益折损;preload 省内存与 fork 安全的取舍;进程与连接池的总量预算。
题目
**业务背景。**一个 Python 写的订单查询与对账 API 服务,单实例部署在 8 核 16 GiB 的容器里,前面是四层负载均衡。服务启动时用多进程模型:主进程先 import 应用、构建 ORM engine 与连接池、初始化 Redis 客户端,然后 fork 出 16 个 worker,每个 worker 起一个同步 HTTP server,单请求内做 1–3 次数据库查询与 1 次 Redis 读取。
**系统规模。**峰值 3200 QPS,平均响应 34 ms,p99 180 ms;数据库连接池配置为每 worker 20 个连接,上限 320;下游 PostgreSQL 的 max_connections 为 500,同实例还跑着另外两个服务;Redis 客户端每 worker 建 1 条连接。
**当前架构与数据流。**主进程 preload(加载代码与初始化客户端)→ fork 16 个 worker → worker 处理请求。上线时单实例 RSS 约 1.1 GiB,主进程 RSS 约 900 MiB;运行 6 小时后每个 worker RSS 都涨到 700 MiB–900 MiB,容器内存接近上限并触发 OOM kill(每次杀掉 1–2 个 worker,由主进程重启补位)。
**目标。**消除 OOM kill 与偶发的响应异常;在不增加实例数的前提下把内存压回安全区间;发布时的优雅重启不能引起错误率尖峰。
**限制条件。**不能改数据库 max_connections;不能把服务改成异步框架(改造窗口在两个月后);不能引入外部连接代理(如 pgbouncer)在本季度内;允许调整进程模型与客户端初始化时机。
已知现象。
- 偶发
psycopg2.OperationalError: server closed the connection unexpectedly与lost synchronization with server: got message type "...",比例约十万分之三,集中在流量高峰与发布后 10 分钟内。 - 偶发响应内容”看起来是别人的”——同一请求 ID 的返回里出现不属于该查询的字段组合(后来确认是同一连接上两次响应被两个进程交错读取)。
- 有 worker 的
pg_stat_activity里连接数显示为 19–20,但数据库侧统计的连接数只有约 180,且application_name里出现同一 backend pid 被多个 client pid 使用。 - RSS 不随请求结束回落;
smaps_rollup显示 private dirty 页远大于共享页,shared 页在运行 1 小时后几乎不再增长。 - 发布后 10 分钟内错误率有 0.4% 的尖峰,集中在旧 worker 退出前后。
需要取舍的问题。“preload 省内存”这个前提在本服务里成立吗?在不增加实例、不改数据库上限的条件下,应该优先修进程模型、修连接池策略,还是修内存回收?请给出判断与方案。
先思考
先问四个问题:(1)fork 之后,父进程建立的那条 TCP 连接在子进程眼里是什么?它是”一条新连接”还是”同一个内核对象”?(2)如果两个进程同时读同一个 socket,会发生什么——是各读各的副本,还是从同一个字节流里各自抢走一部分?(3)写时复制省的是”物理页”,那 Python 里一次普通的属性访问会不会写内存?(4)RSS 高就一定是泄漏吗——共享页和私有脏页分别说明什么?
参考答案
结论:根因是”fork 前建立的连接被 16 个 worker 共同继承”,加上 preload 省内存的假设在引用计数语言里基本不成立。修复顺序是:先断掉跨进程的连接共享(子进程内重建池并以 pid 校验兜底),再按”连接预算”重划 worker 数与池大小,最后才处理内存增长(限制单 worker 生命周期 + 关闭 preload 或接受其有限收益)。
问题拆解(把三个现象分别归因,不要混在一起治)。
现象 1 与 2 是同一个根因的两种表现:文件描述符继承。fork(2) 的文档写得很清楚——“The child inherits copies of the parent’s set of open file descriptors. Each file descriptor in the child refers to the same open file description… the two file descriptors share open file status flags, file offset”。也就是说,父进程在 preload 阶段建立的数据库连接,fork 之后每个子进程都持有一份指向同一个 socket 与同一份协议状态的 fd。PostgreSQL 的协议是有状态的双向字节流(请求/响应按序配对),两个进程同时读写同一条 socket,就会出现”A 进程读走了本该给 B 进程的响应”——这正是”响应内容看起来是别人的”的成因;而协议帧边界错位则会报 lost synchronization。SQLAlchemy 的文档把结论写得很直接:“the pooled connections are not shared to a forked process”,并说明后果”range from non-working connections to socket connections that are used by multiple processes concurrently, leading to broken messaging”。
现象 4 是写时复制的收益折损。fork 采用 COW,父子进程初始共享物理页,任一进程写入时才复制。理论上 preload 能让 16 个 worker 共享同一份代码与只读数据——但 Python 的对象都带引用计数,几乎每次属性访问、每次 Py_INCREF 都在写对象头所在的页,于是”只读共享”迅速退化为”人人私有”。这就是 smaps_rollup 里 private dirty 远大于 shared、shared 一小时不再增长的原因:preload 省下的只是 fork 那一瞬间的页表,随后被引用计数逐个复制掉。再叠加 Python 的内存分配器按 arena 管理、碎片不归还 OS,RSS 自然只涨不落。
现象 5 是优雅重启与连接生命周期的耦合:旧 worker 退出时关闭它持有的连接,若数据库侧仍认为连接可用(或在事务中),请求就会撞上”连接已断”;同时新 worker 冷启动时集中建连,形成建连风暴。
现象 3 是连接预算算错:每 worker 20 × 16 = 320 是本服务的上限,但 PostgreSQL 的 500 是”整个实例”的上限,另外两个服务还要分。数据库侧只看到 180 条,说明池是懒建连的,真实峰值取决于并发;一旦高峰把池打满,就会与另外两个服务争抢剩余的连接额度。
核心方案(三步,按收益排序)。
第一步,禁止跨进程共享连接。两条同时做:(a)把建连从 preload 阶段移出——主进程只 import 代码与配置,不创建 engine、不建 Redis 客户端;连接池在每个 worker 启动后的初始化钩子里创建。(b)加运行时兜底:在连接池 connect 事件里记录 os.getpid(),在 checkout 事件里比对当前 pid,不一致就丢弃该连接并抛一个”需重建”的异常,强制池重新建连。对已经在用共享 Engine 的场景,SQLAlchemy 给出的做法是在子进程初始化时调用 Engine.dispose(close=False),让子进程不触碰父进程的连接池。Redis 客户端同理,且要注意 fork 后子进程只保留调用线程——任何在父进程里持有的锁、连接、后台线程状态都不可信。
第二步,重算连接预算并重划进程模型。可用的数据库连接额度不是 500,而是 500 减去另外两个服务的稳态占用与运维预留(按经验留 15%)。若可用额度约 260,则 worker 数 × 每 worker 池上限 ≤ 260 × 0.8 ≈ 208。两条路径:一是减 worker(16 → 10,池 20 → 20,上限 200),二是减池(16 worker × 13,上限 208)。选择依据是瓶颈在哪:若 p99 的构成里”等连接”占比高,减池会恶化延迟,应减 worker;若 CPU 利用率长期低于 50% 且队列不深,减 worker 更划算。这里的取舍是并发度 vs 单请求排队,不是”哪个数字好看”。
第三步,内存治理。三件事按成本排序:(a)给 worker 设最大请求数 + 随机抖动(例如 2000 ± 400),到量优雅退出由主进程补位——这是唯一能确定性地把 RSS 拉回基线的手段,代价是周期性建连与缓存冷启动;(b)评估是否保留 preload:如果 preload 的收益已被引用计数吃掉,关掉它换”启动即干净”更划算,代价是 16 个 worker 各自 import,启动时间与峰值内存上升(可用”先起 2 个预热、再滚动补足”缓解);(c)在容器内存上限处设一个软水位(如 80%),到水位主动滚动重启最老的 worker,把 OOM kill 变成可控的滚动回收。
**执行流程。**先在 staging 复现:写一个脚本在 fork 前建立 1 条连接、fork 4 个子进程并发跑查询,观察是否出现 lost synchronization(这一步能把根因从”猜测”变成”证据”)。然后按”建连时机外移 → pid 校验兜底 → 预算重算 → 最大请求数”分四次上线,每次只改一项并观测 24 小时:协议错误率、每 worker 的 RSS 与 private/shared 分解、数据库侧连接数与 application_name 分布、发布后 10 分钟的错误率。
技术选型与依据。(1)连接池选型不变,但显式配置”池预热 0、pool_recycle 小于数据库侧 idle_session_timeout、pool_pre_ping 开启”——pool_pre_ping 会在 checkout 时做一次轻量探活,代价是每次多一个 RTT,与”偶发半开连接”相比值得。(2)不引入 pgbouncer(本季度限制),但把”每实例连接预算”写进部署模板,作为后续引入代理的过渡。(3)优雅重启用”先摘流量、再等排空、最后退出”的顺序,preStop 的睡眠时长按”最长请求 + 排空余量”计算,而不是拍一个 5 秒。
**备选方案与否决理由。**备选一:改用线程模型(单进程多线程)。能彻底绕开 fork 语义,但受 GIL 限制、且改造窗口在两个月后,本季度不可行。备选二:给每个 worker 建独立连接池但保留 preload 建连、靠”用完即关”规避共享。这会把连接建立成本摊到每次请求上,3200 QPS 下不可接受。备选三:只调大容器内存。把问题推后 2–3 天,且掩盖了”响应串流”这个正确性缺陷——这类错误不会因为内存变大而消失。
失败路径与恢复。(1)pid 校验漏配某个客户端(例如缓存 SDK、消息队列消费者)→ 表现为修复后仍有零星协议错误;恢复靠”启动时枚举所有持有连接的客户端”清单化,并在集成测试里断言”fork 后 pid 不一致的连接必被拒绝”。(2)最大请求数导致重启过于频繁、建连风暴 → 恢复靠加抖动、错峰、以及重启前预热连接(建 1 条健康连接再放流量)。(3)减 worker 后 p99 恶化 → 恢复靠先减池后减 worker 的顺序,并观测”等连接时间”占比。(4)发布期错误率尖峰 → 恢复靠延长排空窗口、把 readiness 与”已建连”绑定、并在负载均衡侧开启连接排空。
**边界条件与超时。**单请求数据库语句超时 3 秒、连接获取超时 1 秒(拿不到连接要快速失败,不能无限排队,否则 worker 全被占死形成雪崩);事务超时显式设置,避免长事务把连接钉住;worker 退出前必须在 graceful_timeout 内完成在途请求,超时则强制退出并记录;pool_recycle 必须小于数据库的 idle_session_timeout,否则池里全是服务端已关闭的死连接。
重试与幂等。连接层错误(协议错乱、连接被关闭)应当重试一次,但前提是请求幂等——查询类天然可重试,写类必须带幂等键(客户端请求 ID + 唯一索引),否则”重试”会把”连接断开但事务已提交”变成重复写。评测/对账类批任务的重试要按 (batch_id, item_id) 去重。这里的原则是:重试的正确性由业务幂等保证,而不是由连接池保证。
**性能、可用性与验证指标。**性能:关注 p99 的分解(等连接时间 / 查询时间 / 序列化时间),而不是只看总 p99;连接池使用率(活跃 / 上限)长期高于 80% 说明预算不够。可用性:单 worker 崩溃不应影响整体(主进程补位 + 负载均衡摘除),但要限制”单位时间内补位次数”,避免崩溃循环。验证指标:协议错误率(目标 0)、每 worker RSS 与 private/shared 分解、数据库侧连接数与 client pid 分布(应无重复)、发布期错误率尖峰(目标 < 0.05%)、OOM kill 次数(目标 0)。这些指标里,“client pid 分布无重复”是本次修复是否真正生效的直接判据。
关键点
- fork 后子进程继承的 fd 指向同一个 open file description,共享文件偏移与状态标志;有状态的数据库协议被两个进程交错读写必然错乱。
- preload 的省内存收益在引用计数语言里会被 COW 大量折损,判断依据是
smaps_rollup的 private dirty 与 shared 比例,而不是”配置了 preload 就省”。 - 连接预算是”实例级”而不是”进程级”:worker 数 × 池上限 ≤ 可用额度 × 安全系数,且可用额度要扣掉同实例其他服务。
- 修复必须包含运行时判据(pid 校验),因为”记得别在 fork 前建连”是纪律,不是保证。
- 重试的正确性由业务幂等承担;连接层重试只能兜住幂等请求。
常见误区
- “preload 一定省内存,所以一定要开。” 错。省的是 fork 瞬间的物理页;Python 的引用计数会让绝大多数对象页在首次访问后变成私有,收益可能只剩几 MB,却引入了”fork 前不能建连”的硬约束。
- “连接池是按进程隔离的,所以父子进程互不影响。” 错。池对象是进程内的,但池里那些 fd 指向的内核对象是共享的;池隔离掩盖不了 fd 共享。
- “协议错误重试一下就好了。” 错。重试只对幂等请求安全;对写请求,“连接断开”与”事务已提交”无法从错误码区分,盲目重试会造成重复写。
延伸学习
fork(2)man-pages 6.19:重点读 NOTES 中关于 COW 的说明,以及正文里”The child inherits copies of the parent’s set of open file descriptors… share open file status flags, file offset”一段——这是本题所有正确性论证的根:https://man7.org/linux/man-pages/man2/fork.2.html- SQLAlchemy 2.0 Connection Pooling:读 “Using Connection Pools with Multiprocessing or os.fork()” 一节,含四种处理模式(
NullPool、dispose(close=False)、fork 前dispose()、事件钩子 pid 校验):https://docs.sqlalchemy.org/en/20/core/pooling.html
追问
追问 1:如果不改代码,只靠运维手段能不能压住这个问题? 回答要点:能压住表象、压不住正确性。运维能做的:把 worker 数降到 1(彻底消除共享,但牺牲吞吐)、或在启动脚本里把 preload 关掉(若框架支持)。但”响应串流”是正确性缺陷,只要存在多进程共享 fd,任何降低并发的措施都只是降低触发概率;而且概率降低后问题更难被发现。正确做法仍是断掉共享,运维手段只作为过渡。
追问 2:加了 pid 校验之后,为什么还要把建连时机外移?两道防线是否重复? 回答要点:不重复,它们的失效模式不同。建连时机外移消除的是”共享发生”这个条件,成本最低;pid 校验兜住的是”未来有人又在 fork 前建了一条连接”(例如新接入一个 SDK、或 import 阶段发了健康检查请求)。凡是”靠纪律维持”的约束都会随时间腐化,所以配置层要做对、运行时要能证伪。校验本身要足够便宜——一次整数比较,不能因此引入锁或额外 RTT。
追问 3:把 16 个 worker 减到 10 个之后,p99 反而更好,为什么? 回答要点:三种可能,需要数据区分。一是原来 320 条连接的总额度超过了数据库可用额度,部分请求在”等连接”上排队,减 worker 后池不再争抢;二是 CPU 上下文切换与内存带宽争用下降(每 worker 有自己的 arena、GC 与缓存),单请求执行更稳定;三是 OOM kill 减少带来的尾部消除——原来 p99 里混入了重启与冷启动的样本。判断方法是看”等连接时间占比”与”OOM/重启次数”是否同步下降,若两者都没变而 p99 改善,则更可能是第二种。
小型实践(30–60 分钟)
写一个 40 行的复现脚本:父进程先 psycopg2.connect()(或任一有状态 TCP 客户端),然后 os.fork() 出 4 个子进程,每个子进程对同一连接并发执行 200 次简单查询,父进程同时也在用这条连接。观察是否出现 lost synchronization 或响应错配;再把建连挪到 fork 之后重跑同样负载,对比两次的错误率。这个实验能在半小时内把”fd 共享”从文档结论变成你自己的观测,也会让你对”为什么必须有 pid 校验”有直观判断。
L01 LeetCode 438. 找到字符串中所有字母异位词
- 题目 ID:
Q-20261120-L01 - 编号:L01(LeetCode)
- 一级类型:哈希表 / 滑动窗口;二级主题:定长滑窗与计数差异判据
- 难度:medium(LeetCode 页面本次未渲染难度标签,按标准分类记录,未经页面直接核验)
- 考察点:定长窗口的进/出对称更新;用”差异计数”把 O(26) 的窗口比较降为 O(1);窗口长度大于主串、单字符、重复字符堆积等边界。
题目
LeetCode 438. 找到字符串中所有字母异位词(Find All Anagrams in a String),medium。
官方链接:https://leetcode.com/problems/find-all-anagrams-in-a-string/
题目描述(信息完整,非原文照搬):给定两个字符串 s 和 p,找到 s 中所有 p 的字母异位词的起始索引,以任意顺序返回这些索引。字母异位词指字母相同、排列不同的字符串。
输入输出:输入 s(主串)与 p(模式串);输出一个整数数组,元素为满足条件的子串起始下标。
约束:1 <= s.length, p.length <= 3 * 10^4;s 与 p 仅由小写英文字母组成。
示例:
- 输入
s = "cbaebabacd", p = "abc",输出[0,6]。下标 0 的子串"cba"与下标 6 的"bac"都是"abc"的异位词。 - 输入
s = "abab", p = "ab",输出[0,1,2]。
先思考
提示一:异位词的长度一定等于 p 的长度,所以候选子串的位置是确定的——只有 len(s) - len(p) + 1 个。你还需要”枚举所有起点”,还是可以”沿着串滑过去”?
提示二:如果每次都重新统计 26 个字母的频次再比较,单次比较是 O(26)。窗口右移一位时,实际上只有两个字符的频次发生变化。能不能让”是否相等”这个判断也跟着增量更新,而不是每次重算?
提示三:维护一个”当前有多少个字母的频次与 p 不一致”的计数器。它降到 0 的时刻,就是当前窗口是异位词的时刻。注意进出可能是同一个字母(窗口内该字母重复),这时两次更新会落在同一个槽位上,顺序不能错。
参考答案
思路:固定长度为 len(p) 的窗口在 s 上滑动,用一个长度 26 的差值数组 diff 记录”窗口内频次 − p 的频次”,再用一个整数 unbalanced 记录 diff 中非零位置的个数。unbalanced == 0 即当前窗口是异位词。窗口右移时只做两次单点更新(加入右侧新字符、移除左侧旧字符),每次更新 O(1) 地维护 unbalanced。
正确性说明:长度为 m = len(p) 的窗口与 p 互为异位词,当且仅当 26 个字母的频次逐一相等,即 diff 全为 0,等价于 unbalanced == 0。初始窗口的 unbalanced 由完整统计得到;此后每次右移把”旧窗口”变成”新窗口”,恰好移出一个字符、移入一个字符,我们对这两个字符各做一次频次增减,并在增减前后比较该槽位是否跨越 0,从而保证 unbalanced 始终等于当前 diff 中非零项的个数。因此每一个位置被检查时,判据都与该位置的真实窗口一致,不会漏也不会多。
时间复杂度:初始化 O(m + 26),滑动 O(n − m) 次、每次 O(1),总计 O(n + m),其中 n = len(s)。空间复杂度:diff 固定 26 个整数,O(1)(与输入规模无关)。
from typing import List
def findAnagrams(s: str, p: str) -> List[int]: n, m = len(s), len(p) if m > n: return []
# diff[c] = 窗口内字母 c 的个数 - p 中字母 c 的个数 diff = [0] * 26 for ch in p: diff[ord(ch) - 97] += 1 for ch in s[:m]: diff[ord(ch) - 97] -= 1
# 当前有多少个字母的差值不为 0 unbalanced = sum(1 for x in diff if x != 0)
res = [0] if unbalanced == 0 else []
for i in range(m, n): add = ord(s[i]) - 97 # 移入窗口 rem = ord(s[i - m]) - 97 # 移出窗口 # 两个更新必须分别处理:当 add == rem 时它们落在同一个槽位 for idx, delta in ((add, -1), (rem, 1)): before = diff[idx] diff[idx] += delta if before == 0 and diff[idx] != 0: unbalanced += 1 elif before != 0 and diff[idx] == 0: unbalanced -= 1 if unbalanced == 0: res.append(i - m + 1)
return res边界情况:
len(p) > len(s):不存在候选窗口,直接返回空数组(不做这个判断会导致切片与索引越界)。len(p) == len(s):只比较一次,循环一次都不进,答案是[0]或[]。- 窗口内字符高度重复(如
s = "aaaaa",p = "aa"):add == rem,两次更新落在同一槽位,必须先加后减地逐步判断,不能合并成”净变化为 0 就跳过”——因为中间态可能恰好跨过 0。 - 单字符输入(
s = "a",p = "a"):初始窗口即答案。 - 字符集仅小写字母,
ord(ch) - 97合法;若扩展到任意字符,需换成字典或Counter,空间不再是 O(1)。
测试用例:
s = "cbaebabacd", p = "abc"→[0, 6](官方示例)s = "abab", p = "ab"→[0, 1, 2](官方示例)s = "abc", p = "abcd"→[](模式串更长)s = "aaaaa", p = "aa"→[0, 1, 2, 3](同字符反复进出,覆盖add == rem)s = "baa", p = "aa"→[1](只命中一处,验证起点计算i - m + 1)
变体与追问:若要求”返回所有长度大于等于 len(p) 的窗口,只要包含 p 的异位词作为子串”——定长窗口不再适用,需要退回到”用哈希表记录 p 的频次 + 变长窗口 + 一个 formed 计数器”的模板(LeetCode 76 类问题的写法)。若字符集扩大到大字符集(Unicode),diff 数组要换成字典,unbalanced 的维护逻辑不变,但初始化成本变成 O(m + 不同字符数)。
可迁移的能力:这道题真正训练的是”把 O(k) 的整体比较替换为 O(1) 的增量判据”这一模式——先定义一个”当前状态与目标状态的差异度量”,再让窗口每次移动只更新受影响的少数分量。同一个模式在限流滑动窗口的指标聚合、日志窗口内的错误码计数、以及按固定时间片统计的在线特征里反复出现:只要统计口径是”固定长度窗口内的频次”,增量维护差异计数几乎总是比每次重算更划算。
关键点
- 窗口长度固定为
len(p),因此候选起点只有n - m + 1个,无需枚举所有子串。 - 判据必须是”全部 26 个字母频次相等”,任何只比较部分字符或只比较总和的做法都会误判(例如
"ab"与"ac"长度相同、字符和不同,但存在字符和相同的反例)。 unbalanced的维护要按”更新前是否 0 / 更新后是否 0”判断,而不是简单+= 1/-= 1。add == rem(重复字符)时两次更新必须顺序执行,不能合并。- 答案下标是
i - m + 1(i是刚移入的右端点),这是最常见的差一错误来源。
常见误区
- 每次窗口移动后重算 26 个字母的频次再比较。 逻辑正确但把复杂度做到 O(26n),在
n = 3 * 10^4时虽能过,但丢掉了本题真正要考的增量思想;面试官通常会追问”能不能 O(1) 判断”,答不上来就露馅。 - 用”字符 ASCII 和”或”字符乘积”判断异位词。 错。不同字符集合可以有相同的和或积(
"ad"与"bc"),这是典型的哈希碰撞式误判。 - 把
add与rem的更新合并成”如果相同就跳过”。 错。相同字符进出虽然净变化为 0,但unbalanced在两次更新之间可能短暂变化——直接跳过在数学上等价,但一旦你想在循环中做”提前返回”或其他副作用就会出错;更稳妥的写法是老老实实两次更新。
延伸学习
- LeetCode 438 官方题目页(含两示例与约束原文):https://leetcode.com/problems/find-all-anagrams-in-a-string/
- 同族练习方向:把定长窗口换成”最短覆盖窗口”(变长窗口 +
formed计数器),体会”差异计数”模板在两种窗口类型下的复用方式。相关题号(未核验):LeetCode 76 最小覆盖子串、LeetCode 567 字符串的排列。
追问
追问 1:如果 p 很长(接近 s 的长度),这个算法还划算吗?
回答要点:仍然 O(n + m),但常数上初始化占了主要成本;此时”每次重算 26 个字母”与”增量维护”的差距缩小到几乎为零(窗口数量只有 1–2 个)。所以这道题的增量优化在”窗口多、字符集小”时收益最大——这也是判断是否值得做增量维护的通用判据:更新次数 × 单次更新成本 vs 重算次数 × 重算成本。
追问 2:把字符集从 26 个小写字母换成任意 Unicode,你的代码要怎么改?改完之后复杂度怎么变?
回答要点:diff 换成 dict(或 Counter),初始化 O(m),滑动时仍是 O(1) 摊还(字典单点更新),但空间变成 O(不同字符数),且哈希开销高于数组下标。要额外注意 unbalanced 的判据仍然是”值为 0 的键被删除”,实现上建议在值降到 0 时 del 该键,用 len(diff) == 0 作为判据,比遍历所有键更快也更不容易错。
追问 3:如果要求返回的不是起点,而是”每个起点对应的异位词在 p 的所有排列中的字典序排名”,思路会怎么变?
回答要点:这已经超出滑窗范畴,属于”多重集排列的排名”问题:需要先统计 p 的字符频次,再用”逐位确定 + 剩余字符组合数”的方式计算排名(组合数用阶乘与频次阶乘的比值)。滑窗仍然可以用来定位候选窗口,但每个窗口的排名计算是独立的组合数学问题。面试中遇到这种变体,正确的反应是先把问题拆成”定位”与”计分”两段,而不是硬套模板。
当日重点
- **承诺的层级要写清楚。**HTTP/2 承诺的是应用层复用,不是端到端无阻塞;scope 承诺的是动作集合,不是接收方;一次全量评测承诺的是那一刻的快照,不是持续的正确性;preload 承诺的是 fork 瞬间的页共享,不是长期内存节省。凡是把上层的性质当全局性质,就会省掉本层必须做的那次校验或重建。
- **未知态必须显式。**评测里的
inconclusive、TCP 层的”连接已断但事务可能已提交”、fork 后”这条连接到底归谁”——把未知折叠成已知(算通过 / 算失败 / 算没发生),是这类事故的共同加速器。 - 纪律不是保证。“记得不要在 fork 前建连”、“记得给 token 加 audience”、“记得跑全量评测”,都是靠人维持的约束;工程上必须有一个便宜、可自动执行的判据(pid 比较、audience 拒绝、影响面路由表)来接住它。
- **成本优化要落在测量口径上,而不是抽样比例上。**评测的成本大头是”重复测不需要测的东西”,优化的方向是缓存与路由,而不是减少覆盖。
延伸资料汇总
- RFC 9113《HTTP/2》——§1 承认 TCP 队头阻塞未解决,§5.1.2 / §5.2.1 / §5.2.3 给出流并发与流控的真实约束:https://www.rfc-editor.org/rfc/rfc9113.html
- RFC 9114《HTTP/3》——§1.1 / §1.2 / §2 说明为什么把复用下沉到 QUIC:https://www.rfc-editor.org/rfc/rfc9114.html
- MCP 规范 Authorization(最新修订)——CIMD 优先、DCR deprecated、
iss校验判定表:https://modelcontextprotocol.io/specification/latest/basic/authorization - MCP 规范 Authorization(2025-06-18)——早期表述,含 token passthrough 的 MUST NOT:https://modelcontextprotocol.io/specification/2025-06-18/basic/authorization
fork(2)man-pages 6.19——COW 与 fd 共享 open file description:https://man7.org/linux/man-pages/man2/fork.2.html- SQLAlchemy 2.0 Connection Pooling——“Using Connection Pools with Multiprocessing or os.fork()“:https://docs.sqlalchemy.org/en/20/core/pooling.html
- SWE-bench(arXiv:2310.06770)——以真实 issue/PR 与测试用例构造可自动判定任务:https://arxiv.org/abs/2310.06770
本次运行信息
- 配置读取状态:成功,实际生效版本 v9(
last_maintained: 2026-11-16),v9 生效后第 5 次每日出题。启用中的基础题类型 13 个、LeetCode 启用、无暂停类型;观察中的新技术 8 项均未标记”允许试学”,本次未从中出题。本任务未修改题库配置.md。 - 题型分布核对:非 Agent 基础 1(B01)、Agent 基础 1(B02)、Agent 场景 1(S01)、非 Agent 场景 1(S02)、LeetCode 1(L01),合计 5 道。
- 本次参考的历史题目与文件:
题目索引.md(2026-11-19 版,160 条 /indexed_runs: 30)、精选/README.md、README.md导航表、近 30 天题目行(2026-10-22 至 2026-11-19 的全部索引行)。未通读更早训练文件正文。 - 去重结果:B01 与 2026-11-11 B01(SSE 流式传输)、2026-11-17 S02(TCP keepalive)区分——本题是应用层复用与传输层阻塞的分层,不涉及协议面细节;B02 与 2026-11-04 S01(代持令牌与身份传播)、2026-10-20 S01(Server Card 发现)区分——本题是资源服务器侧的 audience / issuer 校验与客户端注册收敛;S01 与 2026-11-03 S01(线上故障定位)、2026-11-11 B02(榜单污染与统计口径)区分——本题是评测流水线的时延/成本/覆盖三角与门禁语义;S02 与 2026-11-05 S02(goroutine 泄漏)、2026-11-02 B01(GC 与 GOMEMLIMIT)区分——本题的根因是 fork 后 fd 共享与 COW 收益折损;L01 与索引内 30 个题号无重合(438 首次出现),算法模式”定长滑窗 + 差异计数”与已用的变长滑窗(3)、滑窗极值(1438)区分。
- 候选淘汰:B01 曾考虑”索引最左前缀与覆盖索引”,因偏记忆型八股弃用;S01 曾考虑”记忆召回精度与陈旧冲突”,与 2026-10-22 S01 同族弃用;S02 曾考虑”Redis Cluster slot 迁移”,因 2026-11-12 S02 已覆盖 Redis 故障转移同族弃用。
- 本地文件:本文件即当日归档,路径
2026-11/2026-11-20-AI-Agent-面试训练.md。索引同日更新:160 → 165 条 /indexed_runs31 /last_updated: 2026-11-20;LC 表新增 438;算法模式段新增”定长滑窗 + 差异计数”并改写下次轮换建议;覆盖表 4 行计数 +1 并补备注;场景题清单 +2 行;页脚改为 31 次 / 2026-08-20 至 2026-11-20;README 导航 +1 行。 - 索引修复(本次附带):发现 2026-11-12 的 4 行(B01 / B02 / S01 / S02)缺少难度、LeetCode ID、状态、是否精选、来源文件五列(历史写入缺陷,非本次引入),已按原始训练文件与 frontmatter 补齐为 15 段,未改动任何历史训练正文;补后 165 行全部列数一致、题目 ID 唯一。
- 远端同步:本次仅完成本地写入,未做任何远端同步验证;不要据此认为远端已同步。