第一章：Go语言面试如何证明你“真写过百万行生产代码”？
面试官不会相信简历上“主导高并发微服务架构”的空泛描述，他们想看到的是你与真实系统搏斗过的痕迹——那些在凌晨三点修复的竞态条件、为降低10ms P99延迟重构的缓冲区策略、以及被压测打垮后重写的连接池实现。
真实场景的细节穿透力
当被问及“如何优化HTTP服务性能”，不要只说“用了pprof”。请展示具体诊断路径：
# 在生产环境安全采样（避免阻塞）
go tool pprof -http=:8080 http://localhost:6060/debug/pprof/profile?seconds=30
# 重点观察：runtime.mallocgc 占比是否异常、net/http.(*conn).serve 是否存在锁竞争接着指出：“我们发现sync.Pool复用bytes.Buffer后，GC pause下降42%，但需注意Pool对象生命周期——我们在http.ResponseWriter WriteHeader后显式调用buffer.Reset()，否则残留数据会污染后续请求。”
生产级错误处理的肌肉记忆
百万行代码的标志是错误不是被忽略，而是被分类治理：
- 可恢复错误（如临时网络抖动）→ 退避重试 + circuit breaker
- 不可恢复错误（如schema校验失败）→ 结构化日志 + Sentry告警 + 业务指标降级标记
- panic兜底：全局
recover()捕获后，记录goroutine stack trace并触发熔断，而非简单log.Fatal
运维协同证据链
| 真正上线过的代码必然留下运维痕迹： | 证据类型 | 具体示例 |
|---|---|---|
| 日志规范 | log.WithFields(log.Fields{"trace_id": ctx.Value("tid")}) 统一注入链路ID |
|
| 配置热更新 | 基于fsnotify监听config.yaml变更，触发viper.WatchConfig() |
|
| 安全加固 | http.Server{ReadTimeout: 5 * time.Second} 显式设置超时，禁用HTTP/1.0 |
这些不是教科书答案，而是你grep过线上日志、翻过监控图表、和SRE一起守过发布窗口的凭证。
第二章：OOM事故复盘——从内存逃逸分析到GC调优的工程闭环
2.1 Go内存模型与逃逸分析实战：用go tool compile -gcflags=”-m”定位高频逃逸点
Go编译器通过逃逸分析决定变量分配在栈还是堆，直接影响GC压力与性能。-gcflags="-m" 是诊断核心工具。
如何启用详细逃逸报告
go build -gcflags="-m -m" main.go # 双-m输出更详细原因
-m输出一次逃逸决策；-m -m显示具体依据（如“moved to heap because …”）。
常见高频逃逸场景
- 函数返回局部变量指针
- 切片扩容超出栈容量
- 接口赋值携带含指针的结构体
- 闭包捕获可变外部变量
典型逃逸代码示例
func NewUser(name string) *User {
return &User{Name: name} // ✅ 逃逸：返回栈变量地址
}
&User{}在栈上分配，但取地址后生命周期需超越函数作用域，编译器强制移至堆。
| 场景 | 是否逃逸 | 原因 |
|---|---|---|
x := 42 |
否 | 纯值类型，作用域明确 |
s := make([]int, 10) |
是（小切片可能否） | 底层数组长度/容量影响决策 |
graph TD
A[源码变量] --> B{逃逸分析}
B -->|地址被返回/存储到全局| C[分配到堆]
B -->|生命周期限于当前栈帧| D[分配到栈]2.2 pprof heap profile深度解读：区分true leak、cache膨胀与sync.Pool误用
识别内存增长模式
go tool pprof -http=:8080 mem.pprof 启动可视化界面后，重点关注 inuse_objects 与 inuse_space 的时间序列趋势：
- 持续线性上升 → 真实泄漏（true leak）
- 阶梯式跃升后平台期 → cache 膨胀
- 周期性尖峰后回落但基线抬高 → sync.Pool 误用
典型误用代码示例
func badHandler(w http.ResponseWriter, r *http.Request) {
buf := bytes.NewBuffer(make([]byte, 0, 1024))
// ❌ 每次请求新建对象，未归还至 Pool
// ✅ 应使用 sync.Pool.Get().(*bytes.Buffer).Reset()
_, _ = buf.WriteString("response")
}此写法绕过 Pool 复用机制，导致堆分配量随 QPS 线性增长，pprof 中表现为 runtime.mallocgc 占比异常升高。
三类问题对比表
| 特征 | true leak | cache 膨胀 | sync.Pool 误用 |
|---|---|---|---|
| 对象生命周期 | 永不释放 | 逻辑上应淘汰但未清理 | Get 后未 Put 回池 |
| pprof 标志 | heap_allocs 持续↑ |
topN 中大量 key 相关对象 |
runtime.mallocgc 高频调用 |
内存回收路径图
graph TD
A[New Object] --> B{归属策略}
B -->|无引用且未注册 finalizer| C[GC 可回收]
B -->|被全局 map 持有| D[Cache 膨胀]
B -->|被 goroutine 长期持有| E[True Leak]
B -->|Pool.Get 但未 Put| F[Pool 无法复用→等效 leak]2.3 GC触发机制与GOGC调优边界：线上低延迟场景下GOGC=50为何反致雪崩
GOGC=50 意味着堆增长50%即触发GC，看似激进回收，实则在高吞吐写入场景中诱发高频STW抖动。
GC触发的隐式代价
当活跃对象持续增长（如实时指标聚合），小堆+低GOGC导致：
- GC频次飙升（每200ms一次）
- Mark阶段抢占P，阻塞goroutine调度
- Stop-The-World时间累积超15ms，突破P99延迟红线
典型误配代码示例
func main() {
os.Setenv("GOGC", "50") // ❌ 未结合实际堆增长速率评估
http.ListenAndServe(":8080", handler)
}
// 分析：该配置忽略应用内存分配模式——若每秒分配8MB且存活率70%，则堆每1.2s涨5.6MB，
// 在初始堆4MB时，仅需~1.7s即触发GC，远超runtime.GC()可控节奏。GOGC与延迟的非线性关系
| GOGC值 | 平均GC间隔 | P99延迟（ms） | STW次数/分钟 |
|---|---|---|---|
| 100 | 3.1s | 8.2 | 19 |
| 50 | 1.4s | 27.6 | 43 |
| 20 | 0.6s | 41.3 | 100 |
graph TD
A[写入突增] --> B{GOGC=50}
B --> C[堆增长50%]
C --> D[强制GC]
D --> E[Mark辅助线程争抢P]
E --> F[HTTP handler goroutine饥饿]
F --> G[延迟毛刺→超时级联]2.4 runtime.MemStats与debug.ReadGCStats在SLO保障中的监控埋点设计
在SLO（Service Level Objective）保障体系中，内存行为是影响延迟尾部（P99+）与服务可用性的关键因子。需将 runtime.MemStats 的高频采样与 debug.ReadGCStats 的GC事件快照协同建模。
数据同步机制
采用双通道采集策略：
MemStats每500ms轮询一次（低开销、高频率）ReadGCStats在每次GC结束时触发（事件驱动、零遗漏）
var m runtime.MemStats
runtime.ReadMemStats(&m)
// m.Alloc: 当前活跃堆内存（直接影响请求延迟）
// m.TotalAlloc: 累计分配量（用于识别内存泄漏趋势）
// m.NumGC: GC总次数（结合时间窗口计算GC频次）
runtime.ReadMemStats是原子快照，无锁安全；但频繁调用会轻微增加调度器压力，建议限频 ≤10Hz。
SLO关联指标映射表
| SLO维度 | 关键指标 | 阈值建议 | 告警动作 |
|---|---|---|---|
| 延迟P99 | MemStats.PauseNs[0] |
> 5ms | 触发GC原因分析 |
| 可用性 | NumGC / 60s |
> 30 | 降级非核心路径 |
| 资源效率 | Sys - Alloc（OS驻留） |
检查cgroup限制 |
graph TD
A[HTTP Handler] --> B{SLO检查点}
B --> C[读取MemStats]
B --> D[订阅GC事件]
C --> E[计算Alloc速率]
D --> F[提取PauseNs分布]
E & F --> G[触发自适应限流]2.5 基于pprof + trace + metrics的OOM根因决策树：从告警到热修复的15分钟响应路径
当 Prometheus 触发 process_resident_memory_bytes > 95% 告警，立即执行三阶诊断流水线：
快速采集内存快照
# 在目标Pod内执行（需提前注入debug port）
curl -s "http://localhost:6060/debug/pprof/heap?debug=1" > heap.out
go tool pprof --alloc_space heap.out # 定位高分配路径--alloc_space 展示累计分配量（非当前驻留），可暴露短生命周期对象的“分配风暴”，如 JSON 解析中重复构建临时 map。
决策树分流逻辑
| 指标特征 | 根因类型 | 应对动作 |
|---|---|---|
heap_inuse > 80% & goroutines > 5k |
协程泄漏 | pprof/goroutine?debug=2 查阻塞点 |
alloc_objects/sec 持续 > 10⁶ |
频繁GC压力 | 检查 runtime/metrics 中 /gc/heap/allocs:bytes 增速 |
自动化响应流程
graph TD
A[告警触发] --> B{heap_inuse > 90%?}
B -->|Yes| C[抓取 trace + heap + metrics]
B -->|No| D[检查 RSS 异常增长]
C --> E[匹配决策树规则]
E --> F[自动注入 runtime.GC() 或重启 worker]核心原则：trace 定时间、pprof 定空间、metrics 定趋势，三者交叉验证方可锁定 OOM 真因。
第三章：panic风暴事故复盘——高并发下的错误传播控制与韧性设计
3.1 panic/recover的调度开销与goroutine泄漏风险：对比defer链式recover与全局panic handler
defer链式recover的隐式成本
每个defer recover()在函数返回前触发，需保存完整的栈帧快照。若嵌套多层defer，会累积调度延迟（平均+120ns/层）并阻塞GMP调度器。
func riskyHandler() {
defer func() {
if r := recover(); r != nil {
log.Printf("recovered: %v", r) // 仅捕获本goroutine panic
}
}()
panic("timeout") // 此panic被立即捕获，但goroutine仍正常退出
}逻辑分析：
recover()必须在panic()同goroutine中且未返回前调用；参数r为任意类型panic值，此处为字符串。该模式无法拦截子goroutine panic，易导致泄漏。
全局panic handler的泄漏陷阱
使用recover()配合runtime.Goexit()可统一处理，但若未显式WaitGroup.Done()或close()通道，则goroutine永不终止。
| 方案 | 调度开销 | goroutine泄漏风险 | 跨goroutine捕获 |
|---|---|---|---|
| defer链式recover | 中（O(n) defer扫描） | 低（本goroutine可控） | ❌ |
| 全局panic handler | 高（需注册/反注册） | 高（易遗漏cleanup） | ✅ |
graph TD
A[panic发生] --> B{是否在defer链中？}
B -->|是| C[recover捕获→栈展开停止]
B -->|否| D[向上传播→goroutine终止]
D --> E[若无监控→泄漏]3.2 context.WithCancel与errgroup.Group在panic级联阻断中的协同模式
当并发任务中某 goroutine panic，需立即终止其余所有子任务并释放资源——此时单靠 context.WithCancel 无法捕获 panic；而仅用 errgroup.Group 又缺乏跨 goroutine 的统一取消信号。二者协同可构建“panic感知型取消链”。
协同机制核心逻辑
errgroup.Group启动所有子任务，并监听首个非-nil error（含errors.Is(err, context.Canceled)）- 每个子任务内嵌
defer func()捕获 panic，将recover()结果转为带堆栈的错误，调用group.Go()的 cancel-aware wrapper
错误传播路径对比
| 场景 | 仅用 context.WithCancel | 仅用 errgroup.Group | 协同模式 |
|---|---|---|---|
| 普通 error 退出 | ❌ 不触发 cancel | ✅ 自动 Cancel | ✅ 双向同步 |
| panic 发生 | ❌ 无感知，goroutines 泄漏 | ❌ panic 未被捕获，主 goroutine 崩溃 | ✅ recover → group.Cancel → context.Done() |
func runWithPanicGuard(ctx context.Context, g *errgroup.Group) {
g.Go(func() error {
defer func() {
if r := recover(); r != nil {
err := fmt.Errorf("panic recovered: %v, stack: %s",
r, debug.Stack())
// 触发全局取消，通知所有兄弟 goroutine
cancel()
g.Wait() // 确保其他任务已响应 cancel
}
}()
return doWork(ctx) // 使用 ctx.Done() 做协作式退出
})
}该代码中 cancel() 是 context.WithCancel 返回的函数，g.Wait() 阻塞至所有任务结束；doWork 内部必须定期检查 ctx.Err()，形成闭环阻断。
3.3 生产环境panic日志标准化：结合stacktrace、goroutine dump与metric tagging的可追溯方案
当服务在生产环境发生 panic，仅靠默认 runtime.Stack() 输出难以定位根因。需融合三类关键上下文：
- 完整 stacktrace：捕获 panic 时所有 goroutine 的调用链（含 source 行号）
- goroutine dump：
runtime.Stack(buf, true)获取阻塞/休眠状态的 goroutine 快照 - metric tagging：注入
service=api,env=prod,revision=abc123等维度标签
日志结构化封装示例
func PanicHook() {
buf := make([]byte, 10<<20) // 10MB buffer for deep stacks
n := runtime.Stack(buf, true) // true → all goroutines
log.WithFields(log.Fields{
"panic": recover(),
"stack": string(buf[:n]),
"metrics": map[string]string{"service": "order", "shard": "us-east-1"},
"ts": time.Now().UTC().Format(time.RFC3339),
}).Fatal("PANIC_WITH_CONTEXT")
}此代码强制捕获全量 goroutine 状态（非仅当前），避免漏掉死锁源头；
10MB缓冲确保超深调用栈不截断；metrics字段支持后续按标签聚合分析。
关键字段语义对齐表
| 字段名 | 来源 | 用途 |
|---|---|---|
goroutine_id |
runtime.GoID()（需 patch） |
精准关联 goroutine 生命周期 |
block_reason |
debug.ReadGCStats() 扩展 |
标识是否因 channel 阻塞 |
trace_id |
opentelemetry.SpanContext() |
跨服务链路归因 |
可追溯性增强流程
graph TD
A[Panic 触发] --> B[捕获 stacktrace + goroutine dump]
B --> C[注入 metric tags & trace context]
C --> D[写入 structured log + Loki]
D --> E[AlertManager 触发带 trace_id 的告警]
E --> F[跳转到 Grafana 日志视图 + Flame Graph]第四章：时钟漂移事故复盘——分布式系统中time.Now()的隐性陷阱与时间语义治理
4.1 monotonic clock与wall clock混合使用导致的TTL误判：Redis过期逻辑失效案例还原
Redis 的过期判定依赖两种时钟源：monotonic clock（如 clock_gettime(CLOCK_MONOTONIC)）用于计算相对流逝时间，wall clock（系统实时时钟）用于存储 expire 时间戳（redisDb.expires 中的 long long 值）。当系统时间被人为回拨（如 NTP step 调整或手动 date -s），wall clock 跳变，但 monotonic clock 不受影响——导致 TTL 计算失准。
关键逻辑分支
- Redis 在
expireIfNeeded()中用mstime() - getExpire()判定是否过期； mstime()返回 wall clock（毫秒级），而getExpire()存储的是 wall clock 时间戳；- 若系统时间回拨 30s，则
mstime()突然减小，大量 key 的mstime() < getExpire()成立 → 被误判为“未过期”，实际已超时。
失效复现代码片段
// src/redis.c:2872 —— 过期检查核心逻辑
long long mstime(void) {
struct timeval tv;
gettimeofday(&tv, NULL); // ← 依赖 wall clock！
return ((long long)tv.tv_sec*1000 + (long long)tv.tv_usec/1000);
}
gettimeofday()返回系统实时时钟，受 NTP step 或管理员干预影响；若在 key 设置后发生-30s回拨，mstime()值骤降，now < expire持续成立，TTL 始终不触发删除。
时钟行为对比表
| 时钟类型 | 是否可回拨 | Redis 中用途 | 抗 NTP step 能力 |
|---|---|---|---|
CLOCK_MONOTONIC |
否 | server.hz 定时器驱动 |
✅ 强 |
gettimeofday() |
是 | mstime()、expire 存储 |
❌ 弱 |
graph TD
A[setex key 60 “val”] --> B[getExpire → wall time T+60000]
C[system time stepped back 30s] --> D[mstime now = T-30000]
D --> E[now < T+60000 → 误判未过期]4.2 NTP校准抖动对ticker精度的影响：用runtime/debug.SetGCPercent验证时序敏感型任务退化
NTP校准引入的系统时钟跳变或频率微调，会直接扰动 time.Ticker 的底层 runtime.timer 调度逻辑，导致周期性事件实际间隔偏离预期。
数据同步机制
当 NTP 守护进程（如 chronyd）执行 slewing 或 step adjustment 时，CLOCK_MONOTONIC 不受影响，但 time.Now()（基于 CLOCK_REALTIME）发生非线性偏移——而 Ticker 内部仍依赖 runtime.nanotime()（映射至 CLOCK_MONOTONIC）做间隔计算，但其唤醒调度器依赖系统 wall clock 对齐，造成唤醒时机漂移。
GC 干扰放大效应
调用 debug.SetGCPercent(-1) 可禁用 GC，排除堆扫描暂停干扰，从而隔离 NTP 抖动的独立影响：
import "runtime/debug"
func setupStableTicker() *time.Ticker {
debug.SetGCPercent(-1) // 禁用 GC，消除 STW 对 ticker 唤醒队列的延迟注入
return time.NewTicker(100 * time.Millisecond)
}此调用强制 GC 进入“永不触发”模式，避免
STW阶段阻塞timerprocgoroutine，使 NTP 抖动成为唯一可观测的时序扰动源。
抖动量化对比
| NTP 模式 | 平均偏差（ms） | P99 抖动（ms） |
|---|---|---|
| slewing（平滑） | ±0.8 | 3.2 |
| stepping（阶跃） | ±12.5 | 47.6 |
graph TD
A[NTP 更新触发] --> B{校准类型}
B -->|Slewing| C[频率微调<br>±0.001%]
B -->|Stepping| D[时钟跳变<br>±10ms+]
C --> E[低抖动 Ticker 唤醒]
D --> F[高概率唤醒延迟/丢失]4.3 基于clock.Clock接口的可测试时间抽象：单元测试覆盖time.Now()依赖的三种注入模式
Go 标准库中 time.Now() 是纯函数式调用，但不可控——这直接破坏单元测试的确定性。解耦时间依赖的核心是依赖倒置：定义 clock.Clock 接口，封装时间获取能力。
为什么需要抽象？
time.Now()隐式全局状态，无法模拟过去/未来时刻- 并发测试中时间跳跃导致竞态断言失败
- 定时器、过期逻辑、日志时间戳等场景必须可控
三种主流注入模式对比
| 模式 | 注入时机 | 灵活性 | 测试侵入性 | 适用场景 |
|---|---|---|---|---|
| 构造函数注入 | 实例创建时传入 | ★★★★☆ | 低（仅修改构造） | 长生命周期服务（如 HTTP handler） |
| 方法参数注入 | 每次调用显式传入 | ★★★☆☆ | 中（需改签名） | 短时计算逻辑（如 token 生成） |
| 上下文注入 | context.Context 携带 |
★★☆☆☆ | 高（需透传 ctx） | 跨层调用链（如 middleware → service） |
示例：构造函数注入实现
type Clock interface {
Now() time.Time
}
type Service struct {
clock Clock
}
func NewService(clock Clock) *Service {
return &Service{clock: clock}
}
func (s *Service) GetTimestamp() string {
return s.clock.Now().Format("2006-01-02")
}逻辑分析：
NewService显式接收Clock实现，彻底隔离time.Now()；测试时可传入clock.NewMock()或clock.NewFake(time.Date(2024,1,1,0,0,0,0,time.UTC))，确保GetTimestamp()返回稳定值。参数clock Clock是接口类型，支持任意实现（真实/模拟/冻结时间），符合里氏替换原则。
graph TD
A[业务代码] -->|依赖| B[Clock接口]
B --> C[realclock：time.Now()]
B --> D[mockclock：固定时间]
B --> E[fakeclock：可进阶]4.4 分布式唯一ID生成器（如snowflake）中时钟回拨的防御性设计：panic→降级→补偿的三级熔断策略
时钟回拨的典型危害
系统时钟向后跳变（如NTP校准、手动修改）会导致Snowflake生成重复ID或ID乱序，破坏全局唯一性与单调递增语义。
三级熔断策略演进
- Panic（熔断）：检测到回拨 > 5ms，立即抛出
ClockBackwardsException并停止ID生成； - 降级（Fallback）：回拨 ≤ 5ms 且连续3次内，启用本地序列号+时间戳哈希兜底；
- 补偿（Recover）：记录回拨事件，异步触发ID段预分配与Redis原子计数器对齐。
// 降级模式核心逻辑（带注释）
if (clockBackwardMs <= 5 && fallbackCounter.increment() <= 3) {
return (System.nanoTime() % 1000L) << 22 | (localSeq.getAndIncrement() & 0x3FFFF);
}
// 参数说明：nanotime低10位取模保证散列，localSeq为ThreadLocal原子计数器，掩码0x3FFFF保留18位序列空间策略对比表
| 阶段 | 触发条件 | 可用性 | ID单调性 | 恢复方式 |
|---|---|---|---|---|
| Panic | 回拨 > 5ms | ❌ | — | 运维介入 |
| 降级 | ≤5ms & ≤3次 | ✅ | ⚠️（局部） | 自动退出 |
| 补偿 | 回拨事件落库后 | ✅ | ✅ | 异步重对齐 |
graph TD
A[检测到currentTs < lastTs] --> B{回拨量 >5ms?}
B -->|是| C[Panic：抛异常+停服]
B -->|否| D{fallbackCount ≤3?}
D -->|是| E[降级：本地seq+hash]
D -->|否| F[补偿：异步ID段重分配]第五章：结语：百万行代码不是数量，而是每一次事故沉淀的工程判断力
真实故障回溯：支付超时雪崩中的三重误判
2023年Q3，某电商中台遭遇持续47分钟的订单创建失败。根因是Redis连接池耗尽，但初期排查路径却依次滑向：①K8s Pod内存泄漏（误删3个健康检查探针）；②MySQL慢查询（执行了12次无索引ORDER BY created_at LIMIT 5000）；③服务网格Sidecar配置错误（实际Envoy版本兼容性正常）。最终在日志时间戳对齐后发现：所有超时请求均发生在redisTemplate.opsForValue().get()调用后3.2±0.1ms——这恰好匹配连接池阻塞等待阈值。团队随后建立「故障决策树」，将“超时集中发生在某类Redis操作”列为一级拦截条件。
工程判断力的量化锚点
| 我们定义三个可审计的判断力指标： | 指标 | 健康阈值 | 事故中实测值 | 改进动作 |
|---|---|---|---|---|
| 首因定位耗时 | ≤8分钟 | 32分钟 | 在APM链路中标记redis:wait事件 |
|
| 误操作导致二次故障率 | 0% | 67% | 所有运维命令强制绑定--dry-run开关 |
|
| 回滚成功率 | ≥99.9% | 41% | 将灰度发布流程嵌入GitOps流水线 |
从代码行数到判断力的转化公式
# 每次P0事故后自动触发的判断力沉淀脚本
def calculate_judgment_score(incident):
return (
(incident.resolution_time / 60) * 0.3 + # 耗时权重
len(incident.root_causes) * 2.5 + # 根因深度
sum(1 for a in incident.actions if a.is_reversible) * 1.2 # 可逆操作数
)
# 示例：某次事故得分为18.7 → 触发架构评审会跨团队判断力迁移实践
金融核心系统将「数据库连接泄漏」判断模式迁移到风控引擎：当发现HikariCP - Connection is not available告警时，不再立即扩容连接池，而是先执行：
jstack $PID | grep -A5 "getConnection"定位阻塞线程栈- 对比
activeConnections与idleConnections的15分钟滑动窗口标准差 - 若标准差>12且
connectionTimeout被重置为0，则判定为连接未释放而非资源不足
判断力的反脆弱性验证
通过混沌工程注入217次故障，统计工程师决策路径收敛速度：
graph LR
A[首次故障] -->|平均需5.2次尝试| B(识别连接池耗尽)
B --> C[第3次同类故障] -->|收敛至2.1次| D(直接检查HikariCP状态页)
D --> E[第12次] -->|100%首因命中| F(自动触发连接泄漏检测脚本)代码仓库里的判断力遗产
在/infra/decision-rules/目录下，每个.md文件记录一次关键判断：
redis-timeout-pattern.md包含2023年7次超时事故的JVM线程快照对比图mysql-join-bug-2022.md附带EXPLAIN分析矩阵（覆盖8种JOIN顺序与索引组合）k8s-oomkiller-trap.md记录cgroup v1/v2内存回收差异的37个测试用例
这些文档被CI流水线强制校验：任何新增SQL必须匹配/decision-rules/中已存的执行计划模式，否则构建失败。
当新工程师在PR中提交SELECT * FROM orders WHERE status='pending'时，预检工具会弹出提示：“该查询在2023-08-12事故中导致全表扫描，请参考/decision-rules/mysql-join-bug-2022.md第4.3节添加复合索引”。
这种约束不是限制创造力，而是把十年间237次生产事故的痛感，压缩成开发者IDE里的一行警告。
