2026-11-19 AI Agent 面试训练
今日学习主题
被当成常量的,其实是参数的函数。相等被当成对象的固有属性,其实是随字段取值变化的契约;模型输出被当成知识的读数,其实是一段分布上的采样;上下文被当成装东西的容器,其实是按 token 计费的预算;执行计划被当成语句的属性,其实由参数分布决定;“每个元素出现了几次”被当成必须存下来的计数,其实可以编码进两个整数。五处故障的共同结构是:把一个依赖输入的映射当成固定的属性,然后去缓存它、断言它、复用它。修正方式也都不是”更小心”,而是承认它是函数并显式标注输入:哈希契约写进类型、事实断言要求可回取的证据、上下文按预算准入、计划按参数特征分流、状态用有限编码压缩。
题目目录
- B01(基础·非 Agent):相等性与哈希契约——为什么把可变对象放进
set之后数据会消失 - B02(基础·Agent):幻觉的成因分层与可控边界——模型说”不知道”时到底发生了什么
- S01(场景·Agent):380 KB 的日志灌进 64K 窗口——工具输出的准入策略与上下文预算
- S02(场景·非 Agent):同一条 SQL 有时 3 ms 有时 4.2 s——参数嗅探、计划缓存与倾斜分布
- L01(LeetCode):137. 只出现一次的数字 II(medium,位运算 + 有限状态机)
运行记录(不入发送内容)
- 配置读取:成功,版本 9(
last_maintained: 2026-11-16),v9 生效后第 4 次每日出题;无暂停类型;观察中的新技术 8 项均未标记”允许试学”,未从中出题。目标目录与父目录仍无AGENTS.md/CLAUDE.md。运行前确认当日文件不存在。 - 历史来源:
题目索引.md(155 条 /indexed_runs: 29/last_updated: 2026-11-18)+精选/README.md(4 条)+ 近 30 天题目行;未通读更早正文。 - 去重:窗口 2026-08-19 至 2026-11-19,窗口内最早条目 2026-10-10,无需剪除。
- L01 代码验证:官方 2 示例 + 4 自建用例 + 3000 组随机对拍(对照 Counter 计数实现)通过;
int32两端边界值通过。 - 已核验来源:LeetCode 137 官方题目页(2 示例、3 条约束、O(n) 时间 + O(1) 空间要求;难度标签未渲染,medium 按标准分类记录并在题内标注);Python 3 文档 Glossary「hashable」词条(哈希值生命周期内不变、需要
__eq__、“Hashable objects which compare equal must have the same hash value”、可变容器不可哈希、不可变容器按元素是否可哈希);Python 3 文档 Data model(is比较身份、不可变容器内含可变对象时”值可变而容器仍不可变”、字典键不接受可变类型的原因是”key 的哈希值必须保持恒定”);Go 规范 Map types(“the key type must not be a function, map, or slice”、interface 键在动态值不可比较时 run-time panic);PostgreSQL 18 文档PREPARE(generic / custom plan 定义、auto默认规则”前五次 custom、比较平均成本后转 generic”、plan_cache_mode三个取值、DDL 与统计更新强制重新分析计划、EXPLAIN EXECUTE中$n与字面量的区别);Ji et al., Survey of Hallucination in Natural Language Generation(arXiv:2202.03629,ACM Computing Surveys 2022,摘要:生成模型”prone to hallucinate unintended text”、综述覆盖度量与缓解手段);Anthropic 工程博客 Effective context engineering for AI agents(2025-09-29:注意力预算、context rot 的 n² 注意力解释、compaction / 结构化笔记 / 子 Agent 三种长任务手段)。 - 本地验证(Python 3 实测,非文档引用):定义
__eq__未定义__hash__的类__hash__为None、入 set 抛TypeError;float('nan')不在含 NaN 的 set 中、用同一对象作键可查到而另一个 NaN 查不到;1 == 1.0为真且哈希相同;Decimal('0.1') == 0.1为假;含 list 的 tuple 不可哈希。 - 未核验:PostgreSQL 规划器内部的选择率默认值(题内不引用具体数值);LeetCode 137 官方题解正文与中文站题名渲染;Python 文档
object.__hash__小节的原文(截断未取到,改以本地行为验证替代)。
B01 相等性与哈希契约:为什么把可变对象放进 set 之后数据会消失
- 题目 ID:
Q-20261119-B01 - 编号:B01(非 AI Agent 基础题)
- 一级类型:编程语言与运行时;二级主题:相等性语义、哈希契约与可变键
- 难度:基础题(中高)
- 考察点:
==与is的语义分工;hashable 契约的两个条件;相等与哈希必须一致的原因;可变对象做键的三种失效形态;跨类型数值相等与 NaN 对去重的影响。
题目
面试官问:“在 Python 或 Go 里,把一个对象放进 set 或 dict,靠的是什么?如果一个对象在放入之后被修改了,会发生什么?请说明哈希与相等之间的契约,以及为什么语言要禁止某些类型做键。最后举一个你在真实代码里见过的、不会报错但结果错误的例子。”
先思考
先分清两件事:a == b 问的是”值是否相等”,a is b 问的是”是否是同一个对象”。再想:哈希表要快速定位,就必须能把对象压缩成一个整数并落到某个桶;如果对象变了、这个整数跟着变,原来放进去的那份数据还在原桶里吗?最后想:语言在什么情况下会大声报错(TypeError / 编译失败),在什么情况下会静默出错——后者才是面试官真正想问的。
参考答案
结论:set 与 dict 依赖的是一个契约而不是一个属性——对象在生命周期内哈希值不变,且”相等则同哈希”。契约一旦被违反,容器不会报错,只会让元素”消失”:按新哈希找不到、旧位置又不可达。所以语言用类型系统把可变类型挡在门外(Python 的 list / dict 不可哈希,Go 的 key 不能是 slice / map / func),而真正的风险来自用户自定义类型:它们看起来不可变、实际可变。
定义与适用边界。可哈希(hashable)在 Python 文档里的定义是:对象在整个生命周期内有一个不变的哈希值(需要 __hash__),并且能与其他对象比较(需要 __eq__)。同一条款还给出了契约的另一半:“Hashable objects which compare equal must have the same hash value.” 适用边界有三条。第一,哈希值不变是硬约束,文档给出的理由很直接:字典的高效实现要求键的哈希值保持恒定。第二,相等与哈希必须同源——如果两个对象 == 为真却哈希不同,它们会被放进两个不同的桶,容器里出现”两个相等的键”,去重与查找同时失效。第三,身份不等于相等:Python 的 is 比较的是身份,id() 返回身份标识;默认的 object.__eq__ 也退化为身份比较,所以”没写 __eq__ 的类”天然按身份区分,一旦加载两次同一行数据就有两个键。
简洁示例(静默失败的那个)。一个表示订单行的类,字段 sku、qty,实现了 __hash__ 基于 sku、__eq__ 也比较 sku,看上去完全一致:
class Line: def __init__(self, sku, qty): self.sku, self.qty = sku, qty def __hash__(self): return hash(self.sku) def __eq__(self, other): return isinstance(other, Line) and self.sku == other.sku
s = {Line("A-1", 2)}line = next(iter(s))line.sku = "A-2" # 业务上"改单"print(line in s) # False:按新哈希找不到print(len(s)) # 1:元素还在,只是不可达s.add(Line("A-2", 3)) # 同一个 sku 出现两次,去重失效这段代码全程不抛异常,len(s) 一直是 1,看起来”一切正常”。这类 bug 在生产里表现为:去重后的集合大小比预期少或多一两条、缓存命中率莫名其妙接近 0、内存缓慢增长而无法用 del 释放。
相近概念区别。与”不可变”的区别:不可变是值不变,可哈希还额外要求相等关系与哈希一致;文档特别指出,一个包含可变对象的不可变容器(如 (1, [2]) 这样的 tuple)本身仍是”不可变”的(你不能替换它的元素),但它不可哈希,因为值可能随内部对象变化——我在本地实测 hash((1, [2])) 抛 TypeError: unhashable type: 'list'。与”值语义 / 引用语义”的区别:值语义描述赋值与传参时的复制行为,哈希契约描述容器索引的前提,两者经常一起出现但不是同一件事。与”排序”的区别:排序需要全序(<),哈希只需要等价关系,不需要可比大小。
典型应用(通用工程)。这一条直接决定四类代码的正确性:缓存键——把 ORM 实体对象直接当缓存键,默认按身份相等,两个 session 加载的同一行是两个键,命中率归零;正确做法是用不可变的值对象或显式的 (table, pk, version) 元组。去重与集合运算——跨类型数值相等会合并:本地实测 1 == 1.0 为真且 hash(1) == hash(1.0),所以 {1, 1.0, True} 的长度是 1;而 Decimal('0.1') == 0.1 为假(实测),混用数值类型会产生”看似同值、实则分裂”的两个键。增量同步与 diff——用可变对象做 set 的差集,等于在变动的地基上做集合运算。测试断言——断言两个对象相等却忘了实现 __eq__,测试会因为身份不同而随机失败。
常见误区或错误用法。其一是”我实现了 __hash__,所以能进 set 了”——如果 __hash__ 与 __eq__ 用的字段不一致(比如哈希用 sku、相等比 (sku, qty)),两个”相等”的对象哈希不同,集合里会出现重复。其二是”先把对象放进去,稍后再补字段”——典型的”构造后填充”模式(obj = X(); obj.id = 1; cache[obj] = v),补字段的那一刻键就失联了。其三是依赖 NaN 的行为:float('nan') != float('nan'),本地实测 float('nan') in {float('nan')} 为 False;用同一个对象作键能查到,换一个等值的 NaN 就查不到——用 NaN 做”缺失值”占位键会静默丢数据。其四是以为 Go 的 map 会兜底:Go 规范要求 key 类型上 == 与 != 必须完全定义,所以 key 不能是 function、map 或 slice;用 interface 作 key 时若动态值不可比较,会在运行时 panic——这是”晚失败”而不是”不会失败”。
面试现场回答(约 90 秒)。set 和 dict 靠的不是”相等”这个直觉,而是两个条件:对象生命周期内哈希不变,且相等则同哈希。Python 文档的原话是”Hashable objects which compare equal must have the same hash value”,理由也很直白——哈希表的高效实现要求键的哈希恒定。所以可变类型被禁止做键,list、dict 不可哈希,含 list 的 tuple 也不可哈希;Go 里 map 的 key 不能是 slice、map、func,interface 键遇到不可比较的动态值会 panic。真正危险的是自定义类型:它看着不可变,实际字段会被改。我见过的一次是订单行对象用 sku 做哈希,改单改了 sku,集合里留下一个再也查不到的”幽灵元素”,去重直接失效,而且全程不报错。工程上的做法是:缓存键与去重键只用不可变值对象或显式元组,__eq__ 和 __hash__ 只读同一组不可变字段,绝不把”构造后填充”的对象放进哈希容器。
关键点
- 哈希契约是两个条件:生命周期内哈希不变,且相等对象哈希相同;缺一个容器就会静默失效。
is/==/hash三者分工:身份用于哨兵与短路,相等用于语义,哈希用于定位;混用时最常见的错误是把身份当相等。- 可变对象做键的失效不报错:按新哈希找不到、旧桶不可达、同一逻辑键被重复插入。
- 跨类型数值相等会合并键(
1、1.0、True),十进制与浮点却会分裂(Decimal('0.1') != 0.1),混用数值类型天然有坑。 - Go 把部分错误前移到编译期(key 不能是 slice/map/func),interface 键则留到运行时 panic。
常见误区
- “实现了
__hash__就安全了”:错。若__hash__与__eq__读的不是同一组字段,两个相等对象会落到不同桶,集合里出现重复键,去重与查找都不成立。 - “对象改了就重新放一次”:错。旧元素仍在旧桶,重新插入只会让容器里同时存在新旧两份,泄漏的是可达性而不是内存引用计数。
- “用
list做 key 报错,说明语言帮我兜住了”:只兜住了内置类型。自定义类默认按身份相等、默认可哈希,把一个可变实体当键不会报错,只会命中率归零。 - “NaN 只是不等于自己,别的都正常”:错。它同时破坏去重与查找:不同的 NaN 对象互不相等,字典按身份短路才可能命中,用 NaN 作”空值”键会静默丢行。
延伸学习
- Python 3 文档 Glossary「hashable」词条与 Data model 中
is/ 身份一节:https://docs.python.org/3/glossary.html#term-hashable 、https://docs.python.org/3/reference/datamodel.html (本轮已核验;object.__hash__小节因页面截断未取到原文,相关行为用本地实测验证)。 - Go 规范 Map types 一节关于 key 类型可比性的要求:https://go.dev/ref/spec#Map_types (本轮已核验)。延伸方向:把”相等关系”当作类型设计的一部分——值对象、不可变数据结构、显式版本号,都是把”哈希契约”从约定变成类型约束的手段。
追问
问:如果确实需要一个”可变但要做键”的对象,工程上怎么处理?
答:不要在可变对象上硬造哈希,而是把它拆成两个东西:一个不可变的身份键(如 (table, pk) 或 uuid 字符串)负责索引,一个可变的值对象负责承载字段。更新时替换值对象而不是原地改键字段;如果必须原地改,就先从容器删除、改完再插入,并把这一步封装成类型的方法,禁止外部直接赋值。另一种做法是把容器换成以身份为键的 dict,需要按值查找时走显式索引(如 sku → id 的反向表),代价是多维护一份索引、收益是”改字段不再有幽灵元素”。Go 里对应的做法是 key 用 struct{ID uint64} 这类只含不可比较字段以外的简单类型,把可变字段放在 value 里。
问:Python 里为什么定义了 __eq__ 就自动把 __hash__ 设为 None?
答:因为在默认实现下,__eq__ 一旦被重写成”按值比较”,就很可能同时引入可变字段;此时若继续沿用身份哈希,就会直接违反”相等则同哈希”。语言选择把这类对象变成不可哈希(本地实测 A.__hash__ is None,入 set 抛 TypeError: unhashable type: 'A'),是用一个早期、响亮的失败换掉一个晚期、静默的错误。要恢复可哈希必须显式声明 __hash__,并自己保证只读不可变字段——这一步的显式性就是设计意图:让作者对契约负责。相同的取舍在 Java 里表现为 equals / hashCode 的成对约定,在 Go 里表现为”结构体可比较当且仅当所有字段可比较”,三种语言都把”相等与哈希同源”当作不可协商的前提。
B02 幻觉的成因分层与可控边界:模型说”不知道”时到底发生了什么
- 题目 ID:
Q-20261119-B02 - 编号:B02(AI Agent 基础题)
- 一级类型:AI 与大模型基础;二级主题:模型能力边界与幻觉
- 难度:基础题(中高)
- 考察点:幻觉的三类成因(参数知识、解码激励、上下文证据);factuality / faithfulness / consistency 三个不同标准;RAG 与温度各自改变了什么;可验证域与不可验证域的对策分工;幻觉率的度量口径。
题目
面试官问:“大模型为什么会’编’?请说明幻觉的成因分类,并解释为什么’降低 temperature”加上检索’都不能消除它。再说明在 Agent 系统里,‘模型不确定’应该由哪一层来表达,以及你会怎么度量幻觉。”
先思考
先想清楚模型在做什么:给定前文,输出下一个 token 的概率分布。那么”我不知道”这句话在训练目标里是被奖励的输出吗?如果不是,模型凭什么在知识缺失时停下来?再想:检索把正确的文档放进上下文,模型就一定会照抄吗——它照抄的是”上下文里最像答案的片段”,而这段片段可能是错的。最后想:哪些场景有确定性判据(能跑一遍就知道对错),哪些没有——两类场景的工程对策完全不同。
参考答案
结论:幻觉不是随机噪声,而是”用概率分布回答事实问题”这一机制的正常输出:训练目标只奖励”像训练分布里的续写”,不奖励”知识缺失时保持沉默”,解码时也没有一个”证据校验”环节。因此它不能被参数调优消除,只能被结构性约束压到可接受水平:把事实获取移到有判据的地方(工具、检索、数据库),把事实断言变成可回取的引用,把”不确定”表达成结构化输出而不是让模型自由发挥。
定义与适用边界。幻觉指模型生成了流畅但无依据或与依据矛盾的内容。工程上至少要区分三个不同的判定标准,混用会让讨论失焦:factuality(与世界事实一致)、faithfulness / groundedness(与给定上下文一致)、consistency(多次运行或自洽性一致)。三者不可互相替代:一段文字可以完全忠实于一份错误文档(faithfulness 高、factuality 低),也可以在多次采样中稳定地重复同一个错误(consistency 高、factuality 低)。适用边界在于:幻觉不可被完全消除,只可按域分级。可验证域(算术、SQL 执行结果、API 返回值、代码能否跑通)有确定性判据,可以让程序判定而不是让模型声明;半可验证域(有权威文档可核对)靠引用与回取;不可验证域(预测、观点、开放建议)只能靠标注不确定性、限制措辞强度、必要时 abstain。
成因分层(三层,各有独立机制)。
- 参数知识层:知识被压缩进权重,天然有容量与时效边界;训练语料里长尾事实稀疏,模型学到的是”最像的模板”而不是”查表”。这一层无法靠提示词修复——提示词改变的是条件分布的选择,不是知识的存在。
- 解码与激励层:训练目标是最大化似然,输出”我不知道”在绝大多数语料里都不是高概率续写;后训练(指令微调、偏好对齐)还会进一步奖励”给出有用的完整回答”,于是”编一个像样的”在期望收益上常常优于”拒答”。这就是为什么降低
temperature没用:它压缩的是采样方差,不改变分布的中心;高概率的错误在低温下依然是高概率,只是变得更稳定。 - 上下文与证据层:检索把文档放进上下文,改变的是”可用证据”,不是”是否会越界推断”。模型会做跨段落拼接、把相似字段张冠李戴、把”示例值”当”真实值”,这些都不违反忠实性判据的形式要求。检索到错误文档时,faithfulness 甚至可以很高。
简洁示例。问”我们租户 T-8842 的退款 SLA 是几小时”,知识库里只有《标准 SLA 24 小时》和一条”大客户另议”的备注。模型很可能输出”T-8842 属大客户,SLA 为 4 小时”——三个动作同时发生:检索到了相关但不适用的文档、把”另议”补成了具体数字、语气上与事实断言无异。这里温度调到 0 也照样输出这句,因为它在分布中心;加一句”不确定就说不确定”能降低概率但不能消除;唯一可靠的做法是让 SLA 从配置表里读(确定性数据源),或要求答案附带可回取的文档段落,并在缺少”该租户专属条款”时返回”未配置,需人工确认”。
相近概念区别。与”模型错误”的区别:错误是结果判断,幻觉强调”无依据地生成”,一个模型可能答错但有依据(文档本身错)。与”知识截止”的区别:截止是时效边界,幻觉是生成机制,前者可以用检索缓解,后者不会因此消失。与”越权 / 过度代理”的区别:那是 Agent 的行为边界问题(该不该做),幻觉是认知边界问题(说的内容是否有依据);两者在工程上会耦合——幻觉出来的参数被工具执行,就变成越权副作用。与”LLM-as-a-Judge 的偏差”的区别:judge 偏差是评价器的问题,幻觉是被评价对象的问题,用有偏的 judge 测幻觉会同时放大两类误差。
典型应用(Agent 系统中的应用)。在 Agent 里,幻觉的代价被工具放大了一个量级,原因有三:其一,模型的输出不再只是文本,而是参数——编造一个订单号,下游会真的去退款;其二,多步轨迹会把一次幻觉变成后续所有步骤的前提(错误前提不会被自动推翻);其三,工具返回值与模型先验冲突时,模型可能选择相信先验。工程上的分工是:模型负责选择、组织与表达,确定性系统负责事实与判定。具体落成三条:所有可枚举的事实(金额、状态、ID、时间窗口)从工具或数据库取,且工具返回值进入上下文时标注来源与 as_of;所有对外可见的事实断言必须带可回取的证据标识(引用段落 ID、查询 ID),无证据的断言由策略层拒绝而不是由提示词劝阻;“证据不足”必须是一等输出状态,与”成功”和”失败”并列,并在评测集中作为独立分桶统计。
常见误区或错误用法。其一,把幻觉当成”提示词写得不够好”,反复加”不要编造”——这会降低发生率但不会改变机制,且会带来过度拒答。其二,用 temperature=0 当”确定性保证”——它只降低采样方差,不改变分布中心,也不保证跨版本、跨硬件可复现。其三,认为 RAG 等于消除幻觉——检索只提供证据,不提供”必须使用证据”的约束;检索质量差时幻觉会更”像真的”。其四,用单一”幻觉率”数字做验收——分母里是否包含”拒答”、由谁判定、样本怎么取,三项任一变化就能让数字翻倍,必须版本化口径。
面试现场回答(约 100 秒)。模型在做的是一件事:给定前文,采样下一个 token。训练目标奖励”像语料里的续写”,不奖励”知识缺失时闭嘴”,解码时也没有证据校验环节,所以幻觉是机制的正常输出,不是 bug。成因分三层:参数知识有容量和时效边界;解码与对齐激励”给完整答案”而不是”说不知道”;上下文里检索到的证据可能不适用或被错误拼接。因此降温度没用——它只压缩方差,不改变分布中心;加检索也不够——它改变可用证据,不保证模型只依据证据推理。工程上我用三个标准分开度量:factuality 对世界、faithfulness 对上下文、consistency 对多次运行。对策按可验证性分级:可验证域直接让程序判定(跑 SQL、跑测试、查配置表),半可验证域要求引用可回取,不可验证域显式标注不确定并允许拒答。在 Agent 里我会把”证据不足”做成一等状态,结论必须带证据 ID,策略层校验引用存在性——把判定权从模型手里拿走,幻觉的代价才可控。
关键点
- 幻觉是”用分布回答事实问题”的机制性输出,不是随机噪声,也不是提示词缺陷。
- factuality、faithfulness、consistency 是三个独立标准,任一项高都不能推出另一项高。
- 温度只压缩采样方差;检索只提供证据;两者都不提供”必须依据证据”的约束。
- 对策按可验证性分级:可验证域交给程序判定,半可验证域要求引用可回取,不可验证域显式表达不确定。
- Agent 中幻觉会通过工具参数被放大,必须把”证据不足”做成一等输出状态并在评测中单独分桶。
常见误区
- “加一句’不要编造’就够了”:这只能降低触发概率,且会把一部分可答问题推成过度拒答;机制没变,长尾仍会编。
- “
temperature=0就是确定性”:错。它只让采样更集中,分布中心的错误依旧稳定复现;跨版本、跨硬件也不保证一致。 - “RAG 之后不再有幻觉”:错。检索到错误或不适用的文档时,faithfulness 可以很高而 factuality 很低,这类错误比无检索时更难被人工发现。
- “用一次人工抽检的幻觉率验收”:口径不可复现。分母是否含拒答、judge 版本、样本分布任一变化都会让数字失真。
延伸学习
- Ji et al., Survey of Hallucination in Natural Language Generation, ACM Computing Surveys (2022),arXiv:2202.03629 — https://arxiv.org/abs/2202.03629 (本轮已核验摘要:生成模型”prone to hallucinate unintended text”,综述覆盖度量、缓解与下游任务差异)。
- Anthropic 工程博客 Effective context engineering for AI agents(2025-09-29)— https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents (已核验:注意力预算、context rot、压缩与结构化笔记的分工,可对照”证据供给不足导致的推断型幻觉”)。
追问
问:如果业务坚持”必须给答案,不允许拒答”,你怎么设计?
答:把”不给答案”换成”给分级答案”。第一,输出来源分层:确定性字段(来自工具或数据库)与推断字段(来自模型推理)在结构上分开,推断字段带置信描述与依据引用,前端用不同措辞呈现。第二,把不确定性外化成可操作项:不只说”可能”,而是给出”需要确认的两个信息”(例如”该租户是否为大客户""合同生效日期”),让用户一步补齐。第三,对高风险动作仍然 fail-closed——“给答案”可以妥协,“执行不可逆动作”不可以,这两件事必须分开授权。度量上把”分级答案的准确率”按层统计(确定性字段的准确率应接近 100%,推断字段单独看),避免用一个混合指标掩盖问题。
问:怎么度量幻觉,才能让数字在两次迭代之间可比?
答:先固定三件事:任务分布(抽样口径,按业务分桶而不是随机抽)、判定方式(能用断言就不用 judge;必须用 judge 时锁定模型版本与提示词版本,并保留人工标注的校准集)、分母定义(拒答与”证据不足”是否计入、部分正确怎么算)。然后分层报告:factuality 用可验证断言(数值、ID、状态)计算精确率;faithfulness 用”断言是否被所引证据支持”逐句判定;consistency 用同一输入的 k 次运行一致率。最后把 judge 与人工的一致率作为元指标挂在报告上——如果一致率掉了,说明数字本身不可信,此时应停止用它做门禁。
S01 380 KB 的日志灌进 64K 窗口:工具输出的准入策略与上下文预算
- 题目 ID:
Q-20261119-S01 - 编号:S01(AI Agent 场景题)
- 一级类型:上下文工程与能力封装(兼 AI Agent 核心、工具与互操作协议);二级主题:上下文写入侧治理、工具输出准入、证据句柄与预算闸门
- 难度:场景题(高)
- 核心考点:上下文预算的”准入”而非”事后压缩”;确定性预筛与模型自主探索的分工;截断的可逆性与省略标注;证据引用与回取;成本与保真度的取舍。
题目
业务背景:一家云服务公司的 on-call Agent,接收监控告警并自动做根因初判、生成工单草稿。Agent 可调用 5 个工具:query_logs(日志平台)、query_metrics(指标平台)、get_trace(链路追踪)、search_runbook(内部知识库)、create_ticket(写操作)。
系统规模:日均 4.2 万次诊断会话,峰值 90 会话/分钟;平均 6 轮工具调用;模型窗口 64K token,按输入 token 计费;工具网关是第三方 MCP 服务的托管实例。
当前架构与数据流:告警 Webhook → 编排器(固定状态机:取证 → 假设 → 验证 → 出单)→ 模型 → 工具网关 → 工具返回的原始 JSON 直接 append 进 messages。日志工具默认返回最近 1000 行原文(单行平均 380 字节),P99 响应体 4 MB;指标工具返回逐分钟序列;trace 工具返回完整 span 树。会话无总预算,仅受模型窗口限制,超限时由编排器调用一次”摘要”把历史压成一段文字。
目标:在不降低根因定位准确率的前提下,把单会话输入 token 的 P95 从 21 万压到 3 万以内、单会话成本从 1.8 元压到 0.4 元以内,并消除”关键证据被工具自身截断”导致的误判。
限制条件:第三方日志/指标/追踪工具不能改服务端行为(query_logs 支持 level、keyword、limit、since 参数,但不支持服务端聚合);不能更换模型;端到端延迟预算只能增加 1.5 秒;审计要求原始输出 90 天内可回取;日志中含用户手机号、邮箱、内部 URL 与临时令牌。
已知现象:上线两个月后出现四个问题。其一,单会话输入 token 的 P95 从 1.9 万涨到 21 万,P95 端到端延迟 46 秒,成本上涨 8.6 倍,但根因定位准确率没有提升(人工抽检 71% → 72%)。其二,12% 的会话出现”日志里没有相关错误”的结论,而人工复核发现错误行就在第 1200 行之后——query_logs 的 limit=1000 默认值静默截断了尾部,模型看到的是一个”干净的”窗口。其三,上下文变长后,system 里”必须先确认告警时间窗口再取证”的约束被模型忽略,开始用默认 15 分钟窗口查日志,与告警实际的 3 小时窗口错配。其四,某次会话把日志中的手机号与内部 URL 原样写进了工单,触发安全审计。
需要取舍的问题:保真度与预算(多留原文更准,但成本与延迟线性上涨);确定性预筛与模型自主(规则筛掉 95% 的行很快,但可能筛掉真正的原因);一次性摘要与可回取句柄(摘要省 token 但不可逆,句柄可回取但要多一次往返与存储)。
先思考
先问:这 21 万 token 里,有多少是模型真的读过并且用到的?如果没有度量,就不知道预算是被”证据”占用还是被”噪声”占用。接着想:有没有一个不依赖模型、成本近零的动作,能先把 4 MB 变成 4 KB 的”目录”?再想:如果截断不可避免,怎么让”被截断”这件事本身变成模型可见的事实,而不是让它误以为看到了全部?最后想:审计要求原始输出可回取——这恰好意味着”外置 + 句柄”是可行路径,而不是只能塞进上下文。
参考答案
结论:问题的根因是上下文没有准入层:工具输出被当成”内容”直接写入,而它其实是”证据”,应当先被索引、摘要、外置,再按需回取。正确做法是在工具网关与编排器之间加一层确定性的证据准入层(解析 → 元数据统计 → 脱敏 → 外置存储 → 生成摘要卡片与句柄),模型只看到”卡片 + 句柄 + 可按模式回取”,并受总预算闸门约束;截断必须显式标注且可逆,结论必须引用证据 ID。这一步把 token 花费从”随工具返回体积线性增长”改成”随取证次数增长”。
问题拆解。四个现象对应四个独立缺陷,不能一起用一个”压缩”动作糊过去:
- 体积失控:原始 JSON 直接入上下文,token 成本 ≈ 工具返回体积,而 P99 返回 4 MB,单次就能吃掉整个窗口。这不是”上下文太长”,是”没有准入”。
- 静默截断:
limit=1000是工具侧默认值,模型看到的是被裁剪过的世界,且没有任何标记说明”后面还有”。这属于能力边界没有暴露,不是模型推理错。 - 约束漂移:system 里的硬约束与大量证据争抢注意力,长上下文下被稀释(context rot:token 越多,准确回忆能力越差)。约束不该待在会被稀释的层里。
- 数据外泄:日志内容未经脱敏就进入模型,模型再写进工单正文——出站通道没有字段白名单。
核心方案(分层,按”确定性优先”排序)。
- 第 0 层:约束不放在会被稀释的地方。把”必须先确认时间窗口”这类硬约束从 system 提示降级为实现约束:编排器状态机在”取证”状态不提供
since参数缺省值,缺参数就拒绝调用并把错误返回给模型(结构化错误,含允许范围)。这是把”提醒”换成”不可能做错”。 - 第 1 层:确定性准入(无模型调用)。工具返回先经过本地处理器:解析 JSON → 计算元数据(总行数、时间范围、level 直方图、错误模板 top-k、trace 的最慢 5 个 span、指标的极值点与突变点)→ PII 脱敏(手机号/邮箱/令牌正则 + 内部域名替换)→ 原始输出写入对象存储(键
task_id/step_id/content_hash)→ 生成 ≤ 800 token 的摘要卡片 +evidence_id。 - 第 2 层:按需下钻。新增
fetch_evidence(evidence_id, mode, pattern, max_lines):mode=grep按正则取匹配行及上下文、mode=range取行区间、mode=tail取尾部 N 行。下钻结果同样过准入层(二级摘要),并计入预算。 - 第 3 层:预算闸门。单次工具结果 ≤ 2K token、单会话累计 ≤ 30K、下钻 ≤ 6 次;超限时返回结构化事实”预算已用尽(已取证 4 段,剩余 0)“,让模型在”收窄范围重查”与”声明证据不足”之间选择,而不是继续堆。
- 第 4 层:结论绑定证据。出单前由策略层校验:结论中每条事实断言必须带存在的
evidence_id;无引用的断言被拒绝(不是提示词劝阻)。工单正文由模板渲染,只允许结构化字段进入,日志原文只以引用链接形式出现。
执行流程。告警进入 → 状态机要求模型先产出”时间窗口 + 受影响服务 + 假设列表”(结构化)→ 工具调用 → 准入层生成卡片并写入 evidence 表 → 模型读卡片,决定是否下钻(下钻请求带 pattern,幂等键 (evidence_id, mode, pattern, max_lines))→ 假设验证阶段只允许引用已有 evidence_id → 出单:模板渲染 + 引用校验 + 出站脱敏二次校验。全程 evidence_id 与 as_of 写进审计。
技术选型与依据。准入层用规则/模板而不是模型调用:确定性、可单测、成本近零、延迟 < 30 ms;只有在需要跨段落语义归纳时才调用小模型(且结果仍要挂 evidence_id,标注”派生摘要”)。外置存储用对象存储 + SQLite/PostgreSQL 索引(按 task_id 查、90 天 TTL 与审计保留分离)。下钻工具做成 MCP 工具而非提示词约定——它必须出现在工具清单里,模型才知道自己”可以再看”,否则模型会以为摘要就是全部。备选方案有二:一是”一次性 LLM 摘要”,实现快但不可逆、丢行、成本反而更高(每次工具调用都多一次模型调用);二是”在工具侧加分页接口”,最干净但本题受限于第三方服务不可改。
方案取舍。保真度 vs 预算:选择”摘要 + 可回取”,用下钻次数换体积,代价是延迟与实现复杂度;确定性预筛 vs 模型自主:预筛只做无损变换(统计、去重、排序、脱敏),不做”哪行重要”的判断——“重要”是模型该做的判断,但必须在可回取的前提下做;摘要 vs 句柄:两者都要,摘要负责”让模型知道有什么”,句柄负责”让模型能再看”。一个明确的取舍点:摘要卡片固定占 800 token,宁可少放细节也要保证每张卡片都带”已省略 N 行”的显式说明,因为”以为自己看全了”比”知道没看全”危险得多。
失败路径与边界条件。对象存储不可用 → 摘要仍可返回,但状态标记 evidence_unavailable,且策略层禁止对该证据做出确定性断言,只能输出”证据不可用,需人工”;不得降级为”凭摘要猜”。解析器失败(非 JSON、编码异常)→ 退化为 head/tail 各 200 行 + 显式省略标记,绝不静默截断。模型反复下钻 → 次数上限 + 相同 pattern 幂等去重 + 结果命中缓存,避免”换个说法再查一遍”。数据源在会话期间变化 → 句柄带 content_hash 与 as_of,回取时校验;不一致则标注”数据已变化”,不允许混用两个时点的证据下结论。空结果必须与”没有错误”区分:工具返回 0 rows 时,卡片必须写明”查询范围 X 到 Y 内无匹配”,而不是返回空字符串——空字符串会被模型读成”一切正常”。
超时、重试、幂等与恢复。单工具 8 s、下钻 5 s、会话 deadline 40 s;超时返回 timeout 状态而非空结果。自动重试只对读类工具,最多 2 次带抖动;create_ticket 用 (task_id, 结论哈希) 做幂等键,重试不产生第二张工单。会话状态(当前假设、已取证 evidence_id 列表、预算余额、待办)持久化在状态机里,进程重启后从状态恢复,不重放历史消息——重放既费钱又会让模型重新走一遍已被否证的路径。恢复后若 evidence 已过 TTL,必须重新取证而不是复用摘要。
安全、成本、延迟与可靠性。安全:PII 在准入层脱敏,出站再做一次白名单校验(工单正文模板只接受 service / window / 假设 / 引用链接);原始日志访问本身要审计(谁、何时、取了哪段),因为”能回取”等于”多了一个数据出口”;日志内容按不可信数据处理,不参与任何策略判定(与间接提示注入的边界一致)。成本:token 花费从”按返回体积”变成”按取证次数”,实测路径下 P95 从 21 万降到 2.6 万;对象存储成本可忽略,主要增量是下钻往返。延迟:准入层 < 50 ms,下钻平均 1.2 次/会话、每次约 300 ms,落在 1.5 s 预算内。可靠性:准入层是无状态纯函数,可水平扩展;它挂掉时的降级是”直通 + 标记未治理”,必须带告警,否则会静默退回旧行为。
评测指标与上线观测。准确率用一个分桶评测集:答案在前 100 行 / 在中间 / 只在尾部 / 需要多模式 grep 组合 / 无答案(应输出证据不足)——最后一桶是本次改造的关键,旧系统在这一桶上的正确率接近 0(它总会给出一个”没发现异常”的结论)。过程指标:会话输入 token 的 p50/p95、下钻次数分布、证据引用覆盖率、摘要省略率、回取命中率、PII 拦截次数、evidence_unavailable 比例、单会话成本。护栏指标:结论被人工推翻率、出单后 24 小时内重开率、平均诊断时长。上线方式:按服务维度灰度(先 5% 低风险服务),对比同一告警集的准确率与成本,双指标同时达标才放量;回滚开关是”直通模式”,回滚必须同时恢复旧提示词,否则约束会以”实现约束”的形态残留。
关键点
- token 花费应随”取证次数”增长,而不是随”工具返回体积”增长——准入层是分界线。
- 硬约束从提示词移到实现:缺参数就拒绝调用,比”再强调一遍”可靠。
- 截断必须显式(“已省略 N 行”)且可逆(句柄 + grep),静默截断会让模型在错误的世界里正确推理。
- 空结果、超时、证据不可用必须是三种不同状态,都不能退化成”没有异常”。
- 摘要负责告知形状,句柄负责保留退路;两者缺一,模型要么盲搜要么失明。
常见误区
- “上下文太长就压缩”:压缩是事后补救,而且不可逆;先把不该进来的挡在门外,压缩的需求本身会消失大半。
- “让模型自己总结工具输出”:多一次模型调用、结果不可回取、失败时无法追溯;规则能做的(统计、去重、脱敏)不要交给模型。
- “用 head/tail 截断就够了”:头尾截断恰好丢掉中间——而中间正是长日志里最可能藏异常的位置;必须有 grep 通道兜底。
- “把原始日志都留着,反正模型会自己忽略”:模型不会忽略,注意力和 token 都会照付,而且长上下文本身会降低对约束的遵守度。
延伸学习
- Anthropic 工程博客 Effective context engineering for AI agents(2025-09-29)— https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents (已核验:注意力预算、context rot、compaction / 结构化笔记 / 子 Agent 三种手段;本题的”准入 + 句柄”对应其”最小高信号 token 集合”原则)。
- MCP 官方规范 Tools 页与 Tasks 扩展 — https://modelcontextprotocol.io/ (本轮未重新核验,按 2026-11-16 已核验记录引用:工具输入须服务端校验、客户端宜校验工具结果)。实践方向:给
fetch_evidence设计分页与next_cursor,把”可回取”做成协议能力而不是应用约定。
追问
问:这套改造会不会让”平均诊断时长”变长,业务能接受吗?
答:单次会话会多 1–2 次往返(下钻),但端到端通常变短,因为上下文从 21 万降到 3 万带来的 prefill 时间下降远大于额外往返。真正需要盯的是长尾:需要多次下钻的会话(比如跨 3 个服务、需要 grep 5 次)会变慢。取舍是给下钻设”并行窗口”——模型可以一次请求同一 evidence_id 的多个 pattern,准入层并行执行并合并结果,把 N 次往返压成 1 次;同时把”预算耗尽”的会话显式标记出来,用人工兜底而不是让模型硬猜。业务侧的承诺应该是”P50 变快、P95 持平、准确率上升”,而不是”每一步都更快”。
问:如果准入层的规则筛错了,把根因行归到了”噪声模板”里,怎么办?
答:这是这套方案最主要的残余风险,要用三重设计兜住。第一,准入层不做删除,只做排序与聚合:top-k 模板之外的行进入”其他”桶并保留计数与句柄,任何时候都能回取,因此”筛错”的代价是多一次下钻,而不是永久丢失。第二,卡片必须暴露”未归类行数”这个数字,让模型知道还有多少内容没被摘要覆盖;数字异常大时编排器可以强制一次 grep 兜底。第三,评测集专门放”根因行属于罕见模板”的样本,衡量下钻触发率与最终准确率——如果这类样本的准确率掉,说明 k 选小了或聚合键选错了,调参而不是改架构。根本原则是:允许筛错,不允许筛丢。
问:如果审计要求”模型看到的每一条内容都能还原”,你的外置方案能满足吗?
答:能,而且比”全塞进上下文”更容易满足。审计需要的是”可还原”,不是”曾经在上下文里”。做法是三步:每条摘要卡片记录 evidence_id、content_hash、as_of 与生成规则版本;原始输出按 content_hash 寻址存储,90 天内可回取且不可篡改(对象锁或 WORM 桶);审计日志记录”哪次会话、哪个步骤、读了哪段”。这样即使摘要规则升级,也能用旧规则版本 + 原始内容重建当时的视图。需要注意两个边界:脱敏是有损的,如果审计要求看到原始手机号,就必须走独立的受控通道(单独授权 + 单独审计),不能让 Agent 的上下文承担这个职责;TTL 到期与审计保留期要分开配置,避免为了审计把热存储成本拖成永久的。
小型实践(30–60 分钟)
写一个约 150 行的 Python 原型:fake_log_tool(limit=1000) 生成 2000 行带 level/时间戳/手机号的模拟日志(根因行放在第 1500 行);实现 admit(payload) -> Card:解析、统计(总行数、level 直方图、错误模板 top-3、未归类行数)、脱敏、原文写入 SQLite、返回摘要卡片与 evidence_id;实现 fetch_evidence(evidence_id, mode, pattern, max_lines) 三种模式与幂等缓存;实现 Budget(单次 2K、累计 30K、下钻 6 次)与超限时的结构化拒绝。构造 5 个用例:答案在前 100 行、在中段、只在尾部、需要正则组合、无答案(必须输出”证据不足”)。验收标准:5 个用例全部正确;任何摘要在省略时都打印”已省略 N 行”;把预算调小到 3K 后,系统输出”预算耗尽”而不是编造结论。
S02 同一条 SQL 有时 3 ms 有时 4.2 s:参数嗅探、计划缓存与倾斜分布
- 题目 ID:
Q-20261119-S02 - 编号:S02(非 AI Agent 场景题)
- 一级类型:数据库与存储;二级主题:prepared statement 的计划缓存、generic / custom plan 与数据倾斜
- 难度:场景题(高)
- 核心考点:generic plan 与 custom plan 的差别及切换规则;计划缓存把”每次最优”换成”平均最优”;参数分布倾斜下的计划敏感性;规划成本与执行成本的权衡;诊断路径与灰度回滚。
题目
业务背景:一个 B2B 电商的订单查询服务,为商家后台提供”按商家 + 时间范围 + 状态”的订单列表查询,走连接池 + 服务端 prepared statement(数据库访问层默认开启语句预编译)。
系统规模:orders 表 8000 万行、order_items 3.2 亿行;日查询 1.2 亿次;头部 200 个商家占全部订单的 18%,另有约 40 万长尾商家单商家订单量中位数 37 行;数据库 PostgreSQL 18,连接池 800 连接,应用实例 40 个。
当前架构与数据流:应用 → 连接池 → PREPARE 一条固定 SQL(WHERE o.merchant_id = $1 AND o.created_at >= $2 AND o.status = $3,join order_items,ORDER BY o.created_at DESC LIMIT 50)→ 每次用不同参数 EXECUTE。表上有 (merchant_id, created_at DESC) 与 (status, created_at DESC) 两个索引,统计信息每日自动 ANALYZE。
目标:把该接口的 P99 从 4.8 s 压到 200 ms 以内,同时不让数据库整体 CPU 上升超过 15%(当前 62%)。
限制条件:不能改表结构(不能加冗余列);可以改 SQL、改应用侧访问方式、改会话参数;发布窗口只有一次,出问题必须能分钟级回滚;高峰期 planning 与执行共享同一批 CPU。
已知现象:接口上线第一天很快(长尾商家 3–6 ms,头部商家 40–80 ms);从第二天起,同一个商家的查询开始出现 3 ms 与 4.2 s 交替的现象,且”慢”的形态高度集中在长尾商家;EXPLAIN 手写同样 SQL 并代入参数时总是走索引,只有服务端执行时偶尔走 hash join + 全表扫;重启应用后短暂恢复正常,几分钟后又变慢;数据库 pg_stat_statements 里该语句只有一个 queryid,mean 32 ms、max 4.9 s。
需要取舍的问题:让每次都用最优计划(custom plan,多付规划成本)还是复用平均计划(generic plan,省规划但可能选错);改 SQL 降低计划敏感性,还是改配置绕过;按语句分类强制,还是全局强制。
先思考
先问一个关键问题:这条 SQL 在”长尾商家”和”头部商家”两个参数下,最优计划是同一个吗?如果不是,那么”复用同一个计划”这件事本身就意味着有一半场景在用别人的最优解。接着想:为什么前几次是快的、后来才变慢——数据库在什么时候会决定”不再为每次执行重新规划”?再想:EXPLAIN 手写 SQL 快、服务端执行慢,这个差异说明了什么。
参考答案
结论:这是计划缓存 + 参数分布倾斜导致的计划劣化。PostgreSQL 默认 plan_cache_mode = auto:前五次执行使用 custom plan 并计算平均估算成本,之后生成 generic plan 与之比较,若 generic 不比平均 custom 差太多就切换过去;generic plan 看不到具体参数值,只能按列的平均统计估算行数,对长尾商家会高估返回行数,从而选 hash join + 全表扫。解法是分流而不是全局调参:对参数敏感的语句强制 custom,对不敏感的保持 auto,同时从 SQL 结构上降低敏感性;先用 EXPLAIN EXECUTE 确认 $1 形态与字面量形态的计划差异,再灰度。
问题拆解。三个现象各自指向不同的机制,先分清再动手:
- “第一天快、第二天慢”:这不是数据增长,而是缓存状态的迁移。前五次执行必然是 custom plan(文档明确”the first five executions are done with custom plans”),所以刚上线、刚重启、刚 failover 时都是”每次重新规划”的状态,看起来正常;一旦切到 generic,问题立刻出现。这条时间线是本题最关键的诊断指纹。
- “同一商家 3 ms / 4.2 s 交替”:说明同一 queryid 下存在两种计划。连接池有 800 个会话,每个会话有自己的 prepared statement 与计划缓存,切换时机各不相同——一部分连接已切 generic(慢),一部分还在 custom(快)。用户请求落到哪个连接就决定了快慢,所以表现为”随机交替”而不是”整体变慢”。
- “
EXPLAIN手写快、服务端慢”:手写 SQL 代入字面量走的是 custom plan,planner 能看到merchant_id = 8842这种高选择性的值;而 generic plan 只能用参数占位符,按平均选择率估算。文档给出的观察方法正是这一点:EXPLAIN EXECUTE name(...)若计划里出现$1,说明用的是 generic plan;出现字面量则是 custom plan。
核心方案(三层,从”最小改动、最快回滚”到”结构性修复”)。
- 第一层(止血,当天可上):对这条语句所在的数据源设置
plan_cache_mode = force_custom_plan(可设在角色级或通过连接初始化参数下发,避免改动 40 个应用的代码)。效果是把”用别人的平均计划”换成”每次按自己的参数规划”。代价是每次执行多一次规划,复杂 join 的规划成本在毫秒级,需要用后面的观测确认 planning CPU 占比可接受。 - 第二层(分流,按语句分类而非全局):不是所有语句都值得强制 custom。用
pg_stat_statements按 queryid 找出”mean 与 max 差距大”的语句(这是一个天然的敏感性信号),只对这些语句强制 custom;其余保持 auto。这避免了”全局 force_custom 把简单查询的规划开销也放大”。 - 第三层(结构,降低敏感性):把一条”既要服务长尾又要服务头部”的查询拆成两条语义等价、计划稳定的查询:按商家维度的查询用
(merchant_id, created_at DESC)索引 +LIMIT(对长尾必然高效);对头部商家的宽时间范围查询走单独路径(可以加更强的过滤条件、或用status索引 + 排序)。SQL 层面还可以做两件事:把ORDER BY ... LIMIT的排序压力交给索引顺序而不是排序节点;对(merchant_id, status)的相关性建扩展统计(CREATE STATISTICS),让规划器知道”这个商家的订单绝大多数是某个状态”,减少估算偏差。注意CREATE STATISTICS属于可回滚的元数据变更,但仍要在低峰执行并观察计划变化。
执行流程(诊断 → 修复 → 验证)。第一步,用 EXPLAIN (ANALYZE, BUFFERS) EXECUTE stmt(8842, ...) 与 EXPLAIN (ANALYZE, BUFFERS) SELECT ... WHERE merchant_id = 8842 ... 对比两种计划,确认慢的那份是 hash join + seq scan、估算行数与实际行数差几个数量级。第二步,在单个会话里 SET plan_cache_mode = force_custom_plan 复测同一参数,确认 P99 回落——这是”根因确认”而不是”碰巧变快”。第三步,用 pg_stat_statements 按 queryid 计算 max/mean 比值,列出候选语句清单。第四步,灰度:先对一个应用实例/一个租户群开启,观察 30 分钟内该 queryid 的 p99 与数据库 planning 时间占比。第五步,稳定后推进 SQL 拆分,把”配置绕过”换成”结构上不敏感”。
技术选型与依据。选择”角色级/连接级参数 + 语句分类”,而不是”改应用代码逐条设置”:参数下发可回滚、影响面可控、不依赖 40 个实例的发布节奏。选择 custom plan 而不是”给规划器喂 hint”:PostgreSQL 没有官方 hint 机制,第三方扩展会引入运维负担与新版本兼容风险。选择 SQL 拆分而不是”无限加大统计目标”:统计只能让估算更准,不能改变”同一语句要服务两种数量级”的根本矛盾——长尾商家返回 50 行、头部商家潜在返回 200 万行,这两件事的最优执行路径本来就不同。备选方案有两个:一是应用侧改用字面量 SQL(不走服务端 prepare),等同永远 custom,但会失去参数化保护、需要严格的类型与转义处理,且在高并发下 planning 开销照样存在;二是给长尾查询加 LIMIT 之外的强约束(比如强制时间窗口上限),能压住最坏情况但不能解决计划选择本身。
方案取舍。custom plan 换来”每次最优”,代价是规划 CPU:高峰期 1.2 亿次查询,若平均规划 0.3 ms,等于 10 个核的持续占用;而当前 CPU 已 62%,所以不能全局强制,只能按语句分类。generic plan 省下的规划成本在简单查询上微不足道(0.05 ms 级),在复杂 join 上才显著——这正是”分类”的依据:用 max/mean 比值识别敏感性,用 planning 时间占比衡量代价。SQL 拆分换来稳定性,代价是两条路径要各自维护、且”边界商家”(订单量刚好在两者之间)可能落到不理想的一侧,需要用实际分布校准分界。回滚成本最低的是参数,最高的是 SQL 拆分,所以顺序必须是”先参数、后结构”,而不是反过来。
失败路径、边界条件与恢复。失败路径一:force_custom_plan 之后 planning CPU 打满,表现为数据库 CPU 上升、简单查询 p99 反而变差——恢复方式是撤回参数(分钟级),并改为按 queryid 精确强制。失败路径二:统计信息刚更新或表结构变更会强制重新分析计划(文档明确 DDL 与统计更新会触发重新 parse/plan),此时会短暂出现计划抖动,需要在发布窗口避开 ANALYZE 高峰。失败路径三:连接池模式下若启用了事务级池化,会话级 SET 可能不生效或串到别的请求上——本题的池是会话级,但方案落地前必须确认池化粒度(这与 2026-11-16 的池化题是同一类陷阱,只是本次的失效点不同)。失败路径四:主备切换后所有会话的计划缓存清空,瞬间变成”全部 custom”,planning 出现尖峰——这是预期行为,需要预散热或临时提高连接复用率。边界条件:status 取值高度倾斜(99% 是 PAID)时,任何以 status 开头的索引都可能被优化器判定为低效;时间范围跨度过大(超过表的一半)时索引扫描本就不如顺序扫描,这类查询应当被应用层拒绝或改走异步导出,而不是指望计划选择解决。
超时、重试、幂等。查询是只读的,重试本身安全;但要注意 40001(序列化失败)与 40P01(死锁)在只读事务里也可能出现,必须整条语句重做而不是部分重试,并带抖动与总预算(例如 800 ms 内最多 2 次)。接口层超时应当小于数据库 statement_timeout,否则会出现”应用已放弃、数据库仍在跑”的浪费——本题把 statement_timeout 设为 1.5 s、应用侧 1.2 s,并让长查询显式失败而不是拖住连接。幂等性在这个读接口上体现为”重复查询不产生副作用”,但如果结果被写入缓存,缓存键必须包含全部过滤条件与 as_of,否则会把”长尾商家的空结果”缓存给头部商家(另一种键不完备导致的错误)。
性能、可用性与验证指标。性能指标:该 queryid 的 p50/p95/p99 按商家分桶(头部/腰部/长尾三桶分别看,聚合数字会掩盖问题);planning time 占总 DB 时间的比例;缓冲命中率与读放大(BUFFERS 里的 shared read);连接池等待时间。可用性指标:数据库 CPU、活跃连接数、statement_timeout 触发次数、5xx 比例。验证方法:用同一批商家 ID 做回放(同一参数集跑新旧两版),逐桶对比 p99 与计划形态;上线后按 5% 实例灰度 30 分钟,双指标(p99 下降、CPU 不升)同时达标才放量。观测面板上必须有一栏”当前会话的 plan 形态分布(generic vs custom)“——否则下次再出现同类问题,仍然只能靠猜。
关键点
auto的规则是”前五次 custom,之后按平均成本决定是否转 generic”——这解释了”刚重启变快”的时间线。- generic plan 看不到参数值,倾斜分布下必然估算偏差;同一 queryid 存在两种计划是”交替快慢”的直接原因。
- 计划缓存是 per-session,800 个连接就是 800 份缓存,切换时机不同步,表现为随机而非整体劣化。
- 修法是分流:用
max/mean比值识别敏感语句,只对其强制 custom;结构上拆分比配置绕过更持久。 - 任何方案都要同时看 p99 与 planning CPU 占比,单看一边会把问题挪到另一边。
常见误区
- “慢就是统计信息过期,
ANALYZE一下”:统计是新的也可能慢——generic plan 根本没用到具体参数值,重新统计只能改变平均值,不改变”看不到参数”这个事实。 - “加索引就能解决”:慢计划常常是没用上已有索引,再加一个索引只会让规划空间更大、劣化形态更多。
- “重启恢复说明是内存或连接问题”:重启清空了计划缓存,等于强制回到 custom,这是”缓存状态”的证据,不是”资源不足”的证据。
- “全局 force_custom 最稳”:把规划开销平摊到所有查询上,高峰期可能把 CPU 打满,反而制造新的 P99 问题。
延伸学习
- PostgreSQL 18 文档
PREPARE(generic / custom plan、auto的前五次规则、plan_cache_mode三个取值、EXPLAIN EXECUTE中$n与字面量之分):https://www.postgresql.org/docs/current/sql-prepare.html (本轮已核验)。 - PostgreSQL 文档
plan_cache_mode配置项与CREATE STATISTICS:https://www.postgresql.org/docs/current/runtime-config-query.html 、https://www.postgresql.org/docs/current/sql-createstatistics.html (入口未核验,按官方文档结构给出;使用前请确认当前版本页面)。延伸方向:把”计划形态”当作可观测指标,而不是只在故障时才EXPLAIN。
追问
问:为什么不直接把 plan_cache_mode 全局设成 force_custom_plan,简单彻底?
答:因为在本题的负载结构下,这是用执行侧的收益换规划侧的亏损。1.2 亿次/天里,绝大多数是简单查询,它们的规划成本对结果没有影响,却会实打实地占 CPU;而当前 CPU 已经 62%,全局强制会把余量吃掉。更关键的是,全局设置掩盖了真正该被识别的东西——哪些语句对参数敏感。用 max/mean 比值筛出敏感语句、只对它们强制,既拿到了收益,也留下了一份”哪些查询在依赖参数”的清单,这份清单本身就是后续 SQL 拆分的输入。工程上”精确的例外”通常优于”粗暴的全局”。
问:如果业务不允许拆分 SQL,也不允许改参数,还有什么办法?
答:剩下的手段都在”让规划器估得更准”和”让查询本身更抗计划”这两条线上。估得更准:对 (merchant_id, status)、(merchant_id, created_at) 建扩展统计(多列相关性),提高该列或该组合的统计目标,必要时对长尾商家的查询加一个恒真的选择性谓词帮助估算——但这些都是”改善估算”,倾斜极端时仍会失效。更抗计划:把 LIMIT 50 的语义前移到子查询(先按索引取 50 个订单 ID,再 join 明细),让”取少量行”这件事在计划层面变得难以被忽略;或者用覆盖索引减少回表,让顺序扫描的代价相对变高。如果两条路都走不通,最后的兜底是应用层分流:对长尾商家走”索引友好”的查询文本,对头部商家走”聚合/异步导出”,用两条语句各自适配自己的参数分布——本质上还是拆分,只是拆在应用层。
问:如果换成 MySQL 或 Oracle,这套判断还成立吗?
答:机制的形态不同,判断逻辑一样。MySQL 8.0 有”参数化查询的计划缓存”,同样存在”同一语句不同参数走不同计划”的可能,而且历史上以”是否使用绑定变量”与”索引统计偏差”为主要诱因;Oracle 有绑定变量窥探(bind peeking)与自适应游标共享(adaptive cursor sharing),后者正是为本题这类问题设计的:它按参数范围维护多份计划,本质上是把”一个语句一份计划”改成”一个语句按选择率分桶的多份计划”。所以可迁移的判断是:当一条语句的最优计划依赖参数分布时,任何”一语句一计划”的缓存都会在某个分桶上出错;解法要么按参数分桶(Oracle 的 ACS、或应用层拆分),要么放弃复用(force custom),要么让语句本身对参数不敏感。这三条与具体数据库无关。
小型实践(30–60 分钟)
用 Docker 起一个 PostgreSQL,建 orders(800 万行即可,merchant_id 用 Zipf 分布生成:1 个商家 30%、其余均匀长尾)与 order_items,建 (merchant_id, created_at DESC) 索引,ANALYZE。写脚本:PREPARE q(int, timestamp, text) AS ...,交替用头部商家与长尾商家参数执行 6 次以上,逐步 EXPLAIN (ANALYZE, BUFFERS) EXECUTE,观察第 6 次开始计划里是否出现 $1、是否从 Index Scan 变成 Hash Join + Seq Scan,记录两次的估算行数与实际行数。然后分别验证三种处置:SET plan_cache_mode = force_custom_plan 后复测;把查询拆成”先取 ID 再 join”的两段式复测;加 CREATE STATISTICS 后复测。验收标准:能画出”执行次数 → 计划形态 → 延迟”的对照表,并说明每种处置把成本挪到了哪里(规划 CPU / 代码复杂度 / 统计维护)。
L01 LeetCode 137. 只出现一次的数字 II
- 题目 ID:
Q-20261119-L01 - 编号:L01(LeetCode)
- 一级类型:位运算;二级主题:按位计数(模 3)+ 有限状态机压缩
- 难度:medium(难度标签本轮在官方页面未渲染,按标准分类记录,未直接核验)
- 核心考点:用两个整数编码”每个位出现 1、2、3 次”的三种状态;状态转移的先后顺序;负数在补码表示下的正确性;O(1) 空间下的计数压缩。
题目
LeetCode 137. 只出现一次的数字 II(Single Number II),medium。
官方链接:https://leetcode.com/problems/single-number-ii/
题目描述(信息完整,非原文照搬):给定整数数组 nums,除某个元素只出现一次外,其余每个元素都恰好出现三次。找出并返回那个只出现一次的元素。要求线性时间复杂度,且只使用常数额外空间。
输入输出:
- 输入:
nums: List[int],长度 1 到 3×10⁴,元素取值-2^31 .. 2^31-1。 - 输出:
int,那个只出现一次的元素。 - 约束:其余每个元素恰好出现三次;要求 O(n) 时间、O(1) 额外空间。
示例:
- 示例 1:输入
[2,2,3,2],输出3(2 出现三次,3 出现一次)。 - 示例 2:输入
[0,1,0,1,0,1,99],输出99(0 与 1 各出现三次,99 出现一次)。
先思考
提示一:如果允许 O(n) 空间,最直接的做法是什么?为什么它不满足要求——是”存了太多东西”,还是”存了不必要的精度”?
提示二:每个二进制位上的”1 的个数”只有三种有效状态:0、1、2,第 3 次会归零。能不能用一个整数表示”当前位已经计数到 1”,用另一个整数表示”已经计数到 2”?
提示三:如果 ones 与 twos 分别表示两种状态,那么读入一个新数 x 时,先更新 ones 还是先更新 twos?注意后更新的一方必须排除”刚刚进入另一状态”的位,否则同一位会被同时记在两个状态里。
参考答案
结论:用两个整数 ones、twos 作为”每个位当前计数 mod 3”的两位编码——ones 的某位为 1 表示该位已出现 1 次,twos 的某位为 1 表示已出现 2 次,两者同时为 0 表示 0 次或 3 次。遍历数组,按 ones = (ones ^ x) & ~twos、twos = (twos ^ x) & ~ones 更新,结束时 ones 就是答案。时间 O(n),额外空间 O(1)。
解题思路(推导过程)。先看暴力:用哈希表计数,时间 O(n)、空间 O(n),不满足要求。再想”计数”到底需要多少信息:对每一位而言,计数只需要模 3,也就是 3 个状态(0、1、2),而 3 个状态可以用 2 个比特编码——这就是 (twos, ones) 这一对整数。关键是把”逐位计数”变成”逐位状态转移”,并且对整个 32 位字并行做:一次位运算同时更新所有位,于是 N 次遍历变成 N 次整数运算。
状态转移的推导:设当前位处于状态 (twos, ones),读入 x 的对应位 b。
- 若
b = 0,状态不变。 - 若
b = 1:(0,0) → (0,1) → (1,0) → (0,0),即 0 次 → 1 次 → 2 次 → 归零。
写成代码时最容易错的是两个式子的顺序与掩码。ones 的新值应当是”异或后仍不在 twos 状态里的位”:ones = (ones ^ x) & ~twos。这里被 ~twos 屏蔽掉的,正是”刚刚由 1 次进位到 2 次”的位——它们必须从 ones 里退出。而 twos 的更新必须使用更新后的 ones:twos = (twos ^ x) & ~ones,这样”刚刚进入 1 次状态”的位不会同时被记进 twos。两句的顺序不能交换:先算 ones、再用新的 ones 算 twos。若先算 twos,则 twos 用的是旧 ones,会把”本次刚变成 1 次”的位也计入 2 次状态,导致状态错乱。
class Solution: def singleNumber(self, nums: list[int]) -> int: ones = twos = 0 for x in nums: ones = (ones ^ x) & ~twos twos = (twos ^ x) & ~ones return ones正确性说明。对每一位独立归纳。设某位在遍历前 i 个元素后,(twos, ones) 表示该位出现次数 mod 3 的值 c ∈ {0,1,2} 的二进制编码(c=0 → (0,0),c=1 → (0,1),c=2 → (1,0))。初始 c=0,成立。读入第 i+1 个元素,该位为 b:
b = 0时,ones ^ 0 = ones,twos ^ 0 = twos,且~twos、~ones不会把已在另一状态中的位激活,两个状态保持不变——与c不变一致。b = 1时:若c=0(ones=twos=0),ones变为 1、twos保持 0,得到c=1;若c=1(ones=1, twos=0),ones ^ 1 = 0且~twos = 全 1,ones变 0,随后twos = (0 ^ 1) & ~0 = 1,得到c=2;若c=2(ones=0, twos=1),ones = (0 ^ 1) & ~1 = 0,twos = (1 ^ 1) & ~0 = 0,回到c=0。三种情况都符合 mod 3 加法。
因此遍历结束后,每一位的状态等于”该位出现次数 mod 3”。除目标元素外所有元素各出现三次,对每一位贡献 3 的倍数,故这些元素的位在最终状态中为 0;目标元素只出现一次,其每一位的最终状态就是它自己的位。于是 ones 逐位等于答案——出现两次的状态(twos)在此题中最后必然为 0(总次数 ≡ 1),答案落在 ones 上。
复杂度。时间 O(n):一次遍历,每次常数次位运算(32 位或 64 位整数上的字级运算)。空间 O(1):只有两个整数。注意这不是”O(1) 因为忽略了常数”,而是真正的常数——计数没有随 n 增长。
关键边界情况。其一,负数:nums 可以取到 -2^31。Python 的整数是任意精度的补码语义,&、~、^ 作用在负数是按无限位补码定义的,因此状态机对负数同样成立;本地实测 [-1,-1,-1,-2] → -2、[-2,-2,-2,1,1,1,-3] → -3 均正确。若是 C++/Java,int 的 32 位补码同样成立,但如果改用”逐位统计 1 的个数再取模”的写法,就必须显式按 32 位处理符号位。其二,单元素数组:[1] 直接返回 1(初始 ones=0,异或后为 1)。其三,最大值与最小值同时出现:[-2^31]×3 + [2^31-1] 与 [2^31-1]×3 + [-2^31] 都验证通过,说明没有符号扩展问题。其四,答案可能为 0,此时 ones 为 0,必须能区分”答案是 0”与”没找到”——题目保证有解,所以直接返回即可,不需要哨兵。
测试用例。
assert Solution().singleNumber([2, 2, 3, 2]) == 3assert Solution().singleNumber([0, 1, 0, 1, 0, 1, 99]) == 99assert Solution().singleNumber([1]) == 1assert Solution().singleNumber([-2, -2, -2, 1, 1, 1, -3]) == -3assert Solution().singleNumber([-2**31] * 3 + [2**31 - 1]) == 2**31 - 1assert Solution().singleNumber([5, 5, 5, 0]) == 0本地验证:官方 2 个示例 + 4 个自建用例 + 3000 组随机对拍(随机生成若干互异值各重复三次,再混入一个唯一值,对照 Counter 计数实现)全部通过。
可迁移的解题能力。这道题训练的是”把状态压缩到常数空间”:当一个计数只需要”模 k”,而 k 很小,就可以用 ⌈log₂k⌉ 个比特编码,再对整个字并行做状态转移。同一思路可以迁移到:用两个变量实现”出现三次中找一次”(本题)、用 ones/twos 扩展成”找出现奇数次的元素”(退化为单变量的异或)、以及用位图表示访存范围(布隆过滤器、去重位图)。另一个可迁移点是”顺序即语义”:ones 与 twos 的更新顺序决定了状态机是否正确,这类”就地更新多个互相依赖的变量”的模式,在滚动数组 DP、滑动窗口计数里反复出现——先算谁、用新值还是旧值,必须能从不变式推出来而不是背下来。
关键点
(twos, ones)是每个位”计数 mod 3”的两位编码,(0,0)/(0,1)/(1,0)对应 0/1/2 次。ones更新时用& ~twos排除”刚进位到 2 次”的位;twos更新时用新ones,顺序不可交换。- 位运算对整个字并行,所以”逐位计数”只需 O(1) 空间而不是 O(位数)。
- 负数依赖补码语义;Python 的任意精度补码使状态机对负数自动成立。
- 答案落在
ones上,twos在本题结束时必为 0(总次数 ≡ 1)。
常见误区
- 把
twos的更新写成(twos ^ x) & ~old_ones:先算twos再算ones,或复用了旧的ones,会让同一位同时处于两个状态,小数据可能仍偶然正确,大数据必错。 - 用求和公式绕开计数:
(3*sum(set(nums)) - sum(nums)) // 2在数学上确实等于答案(设其余互异元素之和为 S、答案为 a,则sum(set)=S+a、sum(nums)=3S+a,两式相减得2a),但它在两处不达标:一是需要 O(n) 的set,违反 O(1) 空间要求;二是在定宽整数语言里3*sum容易溢出,长数组下一个看似正确的公式会静默给出错值。它是个好用的验算工具,不是可提交的解法。 - 逐位统计 1 的个数时忘记符号位:在 C++/Java 中若只循环 0..30 位,负数会算错;Python 中若用”每位求和 mod 3”的写法则需要显式掩码到 32 位,否则负数的无限符号位会污染结果。
- 以为
ones ^ x就够了:那只解决了”出现两次”(异或自消),三次的情形必须引入第二个状态变量。
延伸学习
- LeetCode 137 官方题目页:https://leetcode.com/problems/single-number-ii/ (示例与约束本轮已核验;难度标签未渲染)。
- 位运算状态机的通用背景可参考 Hacker’s Delight(Warren)中”位计数与并行前缀”相关章节(书目与页码未核验);变体练习:LeetCode 136(其余元素出现两次,单变量异或)、LeetCode 260(两个只出现一次的元素,按最低有效位分组),题号与难度未核验。
追问
问:如果题目改成”其余元素出现 k 次,找一个出现一次的元素”,这套写法还能用吗?
答:思路可以,但状态数要从 3 变成 k,编码需要 ⌈log₂k⌉ 个整数,状态转移也不再是两行公式,而是”对每个位维护一个 mod k 计数器”。工程上更通用的写法是按位统计:对 32 个(或 64 个)位分别累加 1 的个数,最后每位 count % k 拼回结果——时间 O(32n),空间 O(1),在 k 不是 3 时更不容易写错。若 k 是 2 的幂(如 4),仍可用类似 ones/twos 的多变量技巧;若 k 很大,就没有必要压缩状态了,直接哈希计数更清晰。这里的判断标准是:压缩的收益是否大于状态机出错的风险——k=3 时公式短且可验证,k=17 时按位统计明显更划算。
问:为什么这个解法在 Python 里对负数也成立,而在 C 里需要小心?
答:因为两者的整数表示语义不同但补码一致。Python 的 int 是任意精度,位运算按”无限位补码”定义,负数向左有无限个 1,~x = -x-1 恒成立;C 的 int 是固定 32 位补码,~ 与 ^ 在固定宽度内封闭。就本题的状态机而言,两种语义下逐位行为完全相同,所以都成立。需要小心的是”按位统计”的写法:在 C 里必须用无符号类型或显式掩码处理第 31 位,否则右移负数会做算术移位、符号位扩散;在 Python 里则要先 x & 0xFFFFFFFF 转成 32 位无符号再统计,否则负数的无限高位会把计数污染。这类”语言表示差异导致的隐性错误”,与 B01 里 Decimal 与 float 混用、1 == 1.0 合并键是同一类问题:语义在语言之间不通用,必须显式声明表示。
当日重点
- 被当成常量的,其实是参数的函数:相等是随字段变化的契约(B01)、模型输出是分布上的采样(B02)、上下文是按 token 计费的预算(S01)、执行计划是参数分布的函数(S02)、计数是可以编码进状态机的量(L01)。识别”这个值依赖什么输入”,比记住具体防护手段更有迁移价值。
- 静默失效比报错危险:改字段后变成不可达的集合元素、
limit=1000造成的”干净窗口”、generic plan 选错的计划——三者都不抛异常,都表现为”看起来正常但结果错”。工程上的对策是同一件事:让边界显式(哈希契约进类型、省略量写在卡片上、$n出现在EXPLAIN里)。 - 不可逆的操作要先降级再优化:截断不可逆(所以要句柄)、一次性摘要不可逆(所以要保留原文)、全局参数不可逆地影响所有语句(所以要分类)。凡是”省下来的东西无法再取回”的优化,都必须先建好回取通道。
- 成本与收益要落在同一张账上:custom plan 的收益是 p99,成本是 planning CPU;摘要的收益是 token,成本是多一次往返。只报收益的方案在下一次容量评审时一定会被打回。
- 判定权应放在有判据的一层:日志里”有没有错误”由查询结果判定,不由模型”感觉”;计划好不好由
EXPLAIN ANALYZE判定,不由延迟猜测;“元素是否相等”由契约判定,不由字段看起来是否一样判定。
延伸资料汇总
| 主题 | 资料 | 类型 | 核验状态 |
|---|---|---|---|
| 哈希与相等契约 | Python 3 Glossary「hashable」— https://docs.python.org/3/glossary.html#term-hashable | 官方文档 | 已核验 |
| 身份与相等、字典键约束 | Python 3 Data model — https://docs.python.org/3/reference/datamodel.html | 官方文档 | 已核验(object.__hash__ 小节页面截断,行为改用本地实测) |
| Go 的可比较性与 map 键 | Go Language Spec, Map types — https://go.dev/ref/spec#Map_types | 语言规范 | 已核验 |
| 幻觉的度量与缓解综述 | Ji et al., Survey of Hallucination in NLG, ACM CSUR 2022 — https://arxiv.org/abs/2202.03629 | 综述论文 | 已核验(摘要) |
| 上下文预算与压缩 | Anthropic, Effective context engineering for AI agents(2025-09-29)— https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents | 官方工程博客 | 已核验 |
| MCP 工具契约 | MCP 规范 Tools 页 — https://modelcontextprotocol.io/ | 官方规范 | 未核验(沿用 2026-11-16 已核验记录) |
| generic / custom plan | PostgreSQL 18 PREPARE — https://www.postgresql.org/docs/current/sql-prepare.html | 官方文档 | 已核验 |
plan_cache_mode 与扩展统计 | PostgreSQL 文档(runtime-config-query、CREATE STATISTICS) | 官方文档 | 入口未核验 |
| 位运算技巧 | Hacker’s Delight(H. S. Warren) | 专著 | 未核验 |
| LeetCode 137 | https://leetcode.com/problems/single-number-ii/ | 官方题库 | 已核验(难度标签未渲染) |
本次运行信息
- 配置读取状态:成功,实际使用版本 9(
last_maintained: 2026-11-16);无暂停类型;观察中的新技术 8 项均未标记”允许试学”,未出题。 - 历史参考:
题目索引.md(155 条 /indexed_runs: 29,窗口 2026-08-19 至 2026-11-19)、精选/README.md(4 条)、近 30 天题目行;未读取更早完整正文。 - 去重结果(逐题区分依据):
- B01 相等性与哈希契约:与 2026-10-23 B01(类型系统型变与擦除)区分——该题考静态类型关系,本题考运行期相等关系与容器索引契约;与 2026-10-29 B01(内存模型与 happens-before)区分——该题考并发可见性,本题考对象在容器中的可寻址性;索引中”序列化""类型系统”均未覆盖本考点。
- B02 幻觉成因与边界:与 2026-10-29 S01(失败反馈与能力边界)区分——该题考产品层如何诚实表达失败,本题考认知层为何会生成无依据内容及三个判定标准的分工;与 2026-11-09 B02(量化)、2026-11-16 B02(KV Cache)区分——同属模型机制但对象不同;与 2026-11-18 S01(间接注入)区分——该题考不可信输入驱动行为,本题考无输入时的知识缺失表达。
- S01 工具输出准入:与 2026-10-21 S01(上下文超限与压缩)区分——该题是”已进入上下文的如何压”,本题是”不该进入的如何挡”(写入侧准入)+可回取句柄;与 2026-11-17 B02(Context Rot 归因)区分——该题考退化机制与归因方法,本题考工程治理与预算闸门;与 2026-11-13 S01(流式状态)区分——该题考输出侧一致性,本题考输入侧体积与保真。
- S02 计划缓存与参数嗅探:与 2026-10-28 B01(统计信息、索引选择与执行计划回归)区分——该题考统计过期导致的计划变化,本题考”统计是最新的、计划仍被缓存复用”;与 2026-11-16 S02(PgBouncer transaction pooling)区分——该题考池化粒度改写会话状态作用域,本题在会话级池化下同样复现,失效点是规划器看不到参数;与 2026-11-10 S02(分区裁剪)区分——该题考裁剪路径,本题考 join 顺序与访问方式的选择。
- L01 137:未出现在索引 LeetCode 表中(146/3/215/739/875/124/207/142/547/560/39/1109/435/208/92/516/31/155/1438/102/198/54/347/151/167/128/946/94/238),位运算模式为首次出题;与 155(栈设计)、946(栈模拟)不同族。
- 候选淘汰记录:B01 曾考虑”特性开关的生命周期与技术债”,因与 2026-10-22 S02(配置全量推送与灰度)同属配置治理一族而弃用;S02 曾考虑”容器内存 limit 与 page cache 误判”,因 2026-11-10 B01(虚拟内存与 THP)与 2026-11-02 B01(GC 与 GOMEMLIMIT)已覆盖相邻机制而弃用。
- 未更新
题库配置.md;未自动精选;未修改任何历史训练文件正文;未执行任何远端同步操作,仅本地写入。