为什么你的Go App上线后OOM频发？——内存泄漏、goroutine泄露与pprof深度诊断实录

第一章：Go App内存问题的典型表征与线上危机意识

当Go应用在生产环境突然出现CPU持续飙高、请求延迟陡增、Pod频繁OOMKilled，或监控图表中RSS内存呈不可逆单向爬升趋势时，这往往不是偶然抖动，而是内存问题正在演变为线上危机的明确信号。Go运行时虽自带垃圾回收器，但其“自动”不等于“无责”——错误的内存使用模式会绕过GC的有效管理，让问题在数小时甚至数天后集中爆发。

常见危险表征

• 堆内存持续增长且GC周期内回收率低于30%：通过runtime.ReadMemStats可验证，重点关注HeapInuse与HeapAlloc差值长期扩大；
• goroutine数量异常激增（>10k）且稳定不降：常伴随net/http连接未关闭、channel阻塞未消费等泄漏源头；
• pprof heap profile中inuse_space顶部显示大量[]byte、string或自定义结构体实例：表明对象生命周期失控；
• 容器RSS远超GOMEMLIMIT或ulimit -v限制，但heap_alloc却未达阈值：提示存在cgo调用、mmap内存或sync.Pool误用导致的非GC堆泄漏。

快速现场诊断指令

# 获取实时内存快照（需应用已启用pprof）
curl -s "http://localhost:6060/debug/pprof/heap?debug=1" | head -20
# 生成火焰图定位高分配路径（需安装go-torch）
go-torch -u http://localhost:6060 -p heap -f heap.svg
# 检查goroutine堆积（输出前50行栈）
curl -s "http://localhost:6060/debug/pprof/goroutine?debug=2" | head -50

线上危机的三个认知误区

误区	真相
“GC触发频繁就说明内存压力大”	可能是小对象高频分配导致GC频次上升，而实际总内存占用并不高
“没有panic就代表系统健康”	RSS持续增长可能静默耗尽节点内存，引发kubelet驱逐或宿主机OOM killer介入
“本地压测没复现，线上就不是代码问题”	真实流量中的长尾请求、连接复用模式、时序竞争条件，在压测中极易被掩盖

真正的稳定性始于对内存行为的敬畏——每一次make([]byte, n)、每一个未关闭的http.Response.Body、每一处未设容量的sync.Pool.Put，都在为下一次OOMKilled埋下伏笔。

第二章：Go内存管理机制深度解析与常见误用场景

2.1 Go内存分配模型：堆/栈/逃逸分析的实战验证

Go 的内存分配决策由编译器在编译期通过逃逸分析（Escape Analysis）自动完成，决定变量分配在栈上（高效、自动回收）还是堆上（需 GC 管理）。

如何观察逃逸行为？

使用 -gcflags="-m -l" 查看详细逃逸信息：

go build -gcflags="-m -l" main.go

实战代码对比

func stackAlloc() *int {
    x := 42          // 局部变量
    return &x        // ❌ 逃逸：取地址后生命周期超出函数作用域
}

func noEscape() int {
    y := 100         // ✅ 不逃逸：仅栈内使用
    return y + 1
}

逻辑分析：stackAlloc 中 &x 导致 x 必须分配在堆上（否则返回悬垂指针），编译器会输出 &x escapes to heap；noEscape 的 y 完全在栈帧内完成计算与返回，零堆分配。

逃逸判定关键规则

• 变量地址被函数外引用（如返回指针、传入闭包、赋值给全局变量）
• 栈空间不足以容纳（如超大数组）
• 类型含指针字段且参与接口赋值（间接逃逸）

场景	是否逃逸	原因
return &localInt	是	地址外泄
return localInt	否	值拷贝，栈内闭环
make([]int, 1000000)	是	大切片默认堆分配

graph TD
    A[源码变量声明] --> B{是否取地址？}
    B -->|是| C[检查引用是否跨函数/协程]
    B -->|否| D[检查大小与上下文]
    C -->|是| E[逃逸至堆]
    D -->|超栈容量或含指针| E
    D -->|小且纯值| F[分配于栈]

2.2 GC触发策略与GOGC调优：从理论公式到压测对比

Go 的 GC 触发由 堆增长比率 决定，核心公式为：
nextGC = heap_live × (1 + GOGC/100)，其中 heap_live 是上一轮 GC 后的存活堆大小。

GOGC 的动态影响

• GOGC=100（默认）：新分配量达存活堆 100% 时触发 GC
• GOGC=50：仅需新增 50% 存活堆即触发，更频繁但降低峰值内存
• GOGC=off（GOGC=0）：仅在内存压力下由 runtime 自主触发（非完全禁用）

压测对比关键指标（16GB 内存实例，持续写入场景）

GOGC	平均 STW (ms)	GC 频次 (/min)	峰值 RSS (GB)
100	3.2	18	9.4
50	1.8	34	7.1
200	5.7	9	12.6

import "runtime/debug"

func tuneGOGC() {
    debug.SetGCPercent(50) // 动态设为 50，生效于下次 GC 周期
}

此调用修改全局 GC 百分比阈值，不立即触发 GC，仅影响后续 heap_live 增长判定逻辑；适用于流量突增前的预防性调优。

graph TD
    A[分配新对象] --> B{heap_alloc - heap_live ≥ nextGC - heap_live?}
    B -->|是| C[启动标记-清除周期]
    B -->|否| D[继续分配]
    C --> E[更新 heap_live & nextGC]

2.3 sync.Pool误用导致的内存膨胀：源码级调试与修复案例

问题复现场景

某高并发日志采集服务在压测中 RSS 持续攀升，GC 周期延长，pprof heap 显示大量 []byte 占据 78% 内存。

核心误用模式

// ❌ 错误：Put 前未重置切片长度，仅清空内容
pool.Put(&bytes.Buffer{Buf: b.Bytes()}) // 实际逃逸为新对象，旧底层数组未回收

// ✅ 正确：复用前显式重置容量与长度
buf := pool.Get().(*bytes.Buffer)
buf.Reset() // 清空 len，但保留 cap，避免 realloc

buf.Reset() 将 buf.len = 0 且不释放底层数组，而错误写法构造新结构体导致原 Buf 被 GC 滞留。

诊断关键指标

指标	正常值	膨胀时表现
sync.Pool.local	稳定 ~NProc	持续增长
runtime.MemStats.HeapInuse	波动收敛	单调上升

修复后内存轨迹

graph TD
    A[请求到来] --> B[Get 复用 buffer]
    B --> C[Write 日志数据]
    C --> D[Reset 清空 len]
    D --> E[Put 回 Pool]
    E --> F[下个请求复用同一底层数组]

2.4 字符串/切片底层结构引发的隐式内存泄漏：unsafe.Pointer实测分析

Go 中字符串与切片均含 header 结构（data + len + cap），但字符串 data 指向只读内存，且其底层数据块生命周期由原始分配者决定——即使切片已超出作用域，只要 unsafe.Pointer 持有其 data 地址，整个底层数组将无法被 GC 回收。

关键泄漏路径

• 从 []byte 转 string 时未复制数据（如 string(b[:])）
• 使用 unsafe.String() 或 (*reflect.StringHeader)(unsafe.Pointer(&s)) 手动构造字符串头
• 将切片 &s[0] 转为 unsafe.Pointer 后长期持有

实测泄漏代码

func leakDemo() *string {
    b := make([]byte, 1<<20) // 分配 1MB
    _ = b[0]
    s := unsafe.String(&b[0], len(b)) // 直接指向底层数组首地址
    return &s // 返回指针 → b 的整个底层数组被 pin 住！
}

逻辑分析：unsafe.String() 构造的字符串 header 中 data 指向 b 的起始地址；GC 会因该字符串存活而保留整个 b 底层 1MB 内存，即使 b 变量已出作用域。参数 &b[0] 是关键锚点，它使 GC root 延伸至原分配块。

对象类型	是否可被 GC	原因
[]byte	✅	无活跃引用时立即回收
string（来自 unsafe.String）	❌	data 指针钉住底层数组

graph TD
    A[make([]byte, 1MB)] --> B[&b[0] → unsafe.Pointer]
    B --> C[unsafe.String ptr]
    C --> D[GC root 引用整个底层数组]
    D --> E[1MB 内存无法释放]

2.5 Context取消链断裂与value泄漏：HTTP中间件中的goroutine生命周期陷阱

HTTP中间件中，若在 goroutine 中直接使用 ctx.WithValue() 或 ctx.WithCancel() 而未绑定父上下文生命周期，极易导致取消链断裂与 value 泄漏。

取消链断裂的典型场景

func timeoutMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        // ❌ 错误：新 cancelCtx 未继承原 ctx 的取消信号
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel() // 但父 ctx 可能早已取消，此处 cancel 无意义
        r = r.WithContext(ctx)
        next.ServeHTTP(w, r)
    })
}

逻辑分析：context.Background() 与请求上下文完全脱钩，父级超时/取消无法传播；cancel() 仅释放本地资源，不触发上游链式取消。

value 泄漏的隐式路径

• 中间件多次调用 ctx.WithValue() 但未限定 key 类型（如用 string 作 key）
• goroutine 持有 ctx 引用并异步执行，而 handler 已返回 → ctx 生命周期被意外延长

风险类型	根本原因	触发条件
取消链断裂	新 context 未基于 request ctx 创建	使用 Background() 或 TODO()
value 泄漏	WithValue 链过长 + goroutine 持有 ctx	异步任务未同步 cancel

graph TD
    A[HTTP Request] --> B[Handler Chain]
    B --> C{中间件创建独立 context}
    C --> D[取消信号丢失]
    C --> E[value 携带至长生命周期 goroutine]
    D --> F[资源无法及时释放]
    E --> F

第三章：goroutine泄露的识别、定位与根因建模

3.1 goroutine状态机与阻塞点分类：runtime.Stack与pprof/goroutine的交叉验证

Go 运行时中，goroutine 生命周期由 G 结构体的状态字段（_Gidle, _Grunnable, _Grunning, _Gsyscall, _Gwaiting, _Gdead）精确刻画。阻塞点本质是状态跃迁的可观测锚点。

阻塞状态映射表

状态值	触发场景	是否可被 pprof/goroutine 捕获
_Gwaiting	channel send/receive、mutex lock	✅（默认显示）
_Gsyscall	系统调用（如 read, accept）	✅（需 GODEBUG=schedtrace=1）
_Grunnable	就绪但未调度	❌（瞬态，通常不可见）

交叉验证实践

// 手动触发 goroutine 阻塞并采集栈
go func() {
    time.Sleep(5 * time.Second) // 进入 _Gwaiting
}()
time.Sleep(100 * time.Millisecond)
buf := make([]byte, 4096)
n := runtime.Stack(buf, true) // true: all goroutines
fmt.Printf("Stack dump:\n%s", buf[:n])

该调用强制捕获所有 goroutine 栈帧，_Gwaiting 状态会显式标注 "goroutine X [sleep]"；与 curl http://localhost:6060/debug/pprof/goroutine?debug=2 输出比对，可定位阻塞点是否被 pprof 漏报。

状态跃迁可视化

graph TD
    A[_Grunnable] -->|schedule| B[_Grunning]
    B -->|chan send| C[_Gwaiting]
    B -->|syscall| D[_Gsyscall]
    C -->|channel ready| A
    D -->|syscall return| A

3.2 channel未关闭/未消费导致的goroutine积压：并发模式重构实践

问题复现：泄漏的 goroutine

以下代码启动 100 个 goroutine 向无缓冲 channel 发送数据，但仅消费前 10 个：

ch := make(chan int)
for i := 0; i < 100; i++ {
    go func(id int) {
        ch <- id // 阻塞在此，永不返回
    }(i)
}
for j := 0; j < 10; j++ {
    <-ch
}
// 剩余 90 个 goroutine 永久阻塞，无法回收

逻辑分析：ch 为无缓冲 channel，发送方在无接收者就绪时永久挂起；主 goroutine 退出后，阻塞的 goroutine 成为孤儿，造成内存与调度资源持续占用。

重构方案对比

方案	是否解决积压	是否需显式关闭	适用场景
select + default 非阻塞发送	✅	❌	高吞吐丢弃策略
带超时的 select	✅	❌	弱一致性要求
context.WithTimeout + 关闭 channel	✅✅	✅	强可控性、优雅终止

数据同步机制

采用带 cancel 的 channel 模式：

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()

ch := make(chan int, 10) // 改用有缓冲，缓解压力
for i := 0; i < 100; i++ {
    select {
    case ch <- i:
    case <-ctx.Done():
        return // 提前退出所有发送
    }
}

参数说明：ctx.Done() 触发后，所有 select 立即退出；缓冲区大小 10 允许短时背压，避免瞬间 goroutine 爆炸。

3.3 timer.Reset滥用与time.After泄漏：定时任务系统的可观测性加固

常见反模式：Reset未校验返回值

timer.Reset() 返回 bool，表示是否成功重置（若 Timer 已停止或已触发则返回 false）。忽略该返回值会导致定时器静默失效：

t := time.NewTimer(5 * time.Second)
// ... 业务逻辑
if !t.Reset(3 * time.Second) {
    // ❌ 错误：未重建Timer，后续<-t.C将永远阻塞
}

逻辑分析：Reset 在 Timer 已过期时返回 false，但原 Timer 进入“stopped”状态，其通道不再发送信号。必须显式重建：t = time.NewTimer(3 * time.Second)。

time.After 的隐蔽泄漏

time.After(d) 底层调用 NewTimer(d) 并返回 <-C，但不提供 Stop 接口，导致无法回收底层资源：

场景	是否泄漏	原因
select { case <-time.After(10s): ... }（单次）	否	Timer 自动 GC
循环中高频调用 time.After(100ms)	是	每次创建新 Timer，旧 Timer 未 Stop，goroutine & channel 持续堆积

可观测性加固方案

• 使用 prometheus.NewCounterVec 统计 timer_reset_failed_total
• 通过 runtime.ReadMemStats 监控 NumGC 与 Mallocs 异常增长
• 在关键路径注入 debug.SetGCPercent(-1) 临时定位 Timer 泄漏点

graph TD
    A[定时任务启动] --> B{Reset调用}
    B -->|返回false| C[重建Timer并记录metric]
    B -->|返回true| D[正常续期]
    C --> E[上报reset_failure标签]

第四章：pprof全链路诊断体系构建与生产环境落地

4.1 pprof HTTP端点安全启用与权限隔离：Kubernetes Ingress+Basic Auth实战配置

pprof 默认暴露于 /debug/pprof/，若未加防护将导致敏感运行时数据泄露。在生产 Kubernetes 环境中，需通过 Ingress 层统一收敛并强化认证。

安全加固路径

• 禁用默认服务暴露（--pprof=false 或反向代理拦截）
• 使用 nginx.ingress.kubernetes.io/auth-type: basic 启用基础认证
• 将 pprof 路径重写为受限子路径（如 /admin/pprof/）

Ingress 配置示例

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations:
    nginx.ingress.kubernetes.io/auth-type: "basic"
    nginx.ingress.kubernetes.io/auth-secret: "pprof-auth"
    nginx.ingress.kubernetes.io/rewrite-target: "/debug/pprof/"
spec:
  rules:
  - http:
      paths:
      - path: /admin/pprof(/|$)(.*)
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 8080

该配置将 /admin/pprof/ 请求重写为容器内 /debug/pprof/，同时强制 Basic Auth。auth-secret 必须是包含 auth 键的 Secret（htpasswd -c -b auth admin $PASS 生成）。

组件	作用	安全要求
Ingress Controller	终止 TLS、执行认证与路径重写	需启用 auth-url 或原生 basic 支持
Secret pprof-auth	存储 Base64 编码的 htpasswd 文件	必须限定 namespace + RBAC 只读
应用容器	禁用非必要调试端口，仅响应重写后路径	建议设置 readinessProbe 排除 /debug/pprof/

graph TD
  A[客户端请求 /admin/pprof/] --> B[Ingress Controller]
  B --> C{Basic Auth 检查}
  C -->|失败| D[HTTP 401]
  C -->|成功| E[重写为 /debug/pprof/]
  E --> F[后端 Pod]
  F --> G[返回 pprof 数据]

4.2 heap profile采样策略优化：go tool pprof -alloc_space vs -inuse_space的业务语义解读

Go 运行时 heap profile 提供两种核心视角，其差异直指内存生命周期的关键断点：

alloc_space：全量分配快照

反映程序启动以来所有 malloc 操作累计字节数，包含已释放对象。适用于诊断内存泄漏源头或高频小对象分配热点。

go tool pprof -alloc_space ./myapp mem.pprof

-alloc_space 统计 runtime.mallocgc 调用总量，不区分存活状态；适合排查“为何内存增长过快”，但无法反映当前压力。

inuse_space：实时驻留视图

仅统计当前仍在堆上存活的对象总字节数，对应 GC 后的活跃内存水位。

go tool pprof -inuse_space ./myapp mem.pprof

-inuse_space 反映 runtime.gcControllerState.heapLive 快照，精准刻画服务真实内存占用，是 SLO 容量规划依据。

场景	推荐 flag	业务语义
分析 GC 频率异常	-inuse_space	当前驻留内存是否持续攀升？
定位字符串拼接爆炸	-alloc_space	是否在短周期内重复分配 MB 级临时缓冲？

graph TD
    A[内存分配事件] --> B{是否已 GC 回收？}
    B -->|是| C[计入 -alloc_space<br>不计入 -inuse_space]
    B -->|否| D[同时计入两者]

4.3 trace profile深度解读：G-P-M调度事件、GC STW、网络阻塞的时序归因分析

trace.Profile 是 Go 运行时提供的低开销时序采样工具，聚焦于 Goroutine（G）、Processor（P）、Machine（M）三元调度状态跃迁。

G-P-M 状态跃迁关键点

• Grunnable → Grunning：P 抢占空闲 G，触发调度器唤醒
• Gwaiting → Grunnable：如 netpoll 就绪后批量唤醒网络阻塞 G
• Pgcstop 事件紧邻 GCSTWStart，标识 STW 全局暂停起点

GC STW 与网络阻塞的时序耦合

// 示例：trace.Start() 后触发强制 GC 并观测 STW 区间
runtime.GC() // 触发 GC，trace 记录 GCSTWStart/GCSTWEnd 事件

该调用会强制进入 STW 阶段；trace 中若见 GCSTWStart 后紧接大量 Gwaiting（原因码 netpoll），表明网络 I/O 队列积压在 STW 期间被延迟处理。

时序归因分析核心维度

维度	观测指标	异常阈值
调度延迟	Grunning 到 Grunnable 间隔	>100μs
GC STW 时长	GCSTWEnd - GCSTWStart	>500μs（非大堆）
网络就绪延迟	Gwaiting(netpoll) 持续时间	>10ms

graph TD
    A[trace.Start] --> B[采集 G-P-M 状态跃迁]
    B --> C{检测 GCSTWStart}
    C -->|是| D[标记 STW 起点]
    C -->|否| E[继续采样]
    D --> F[关联后续 Gwaiting netpoll 事件]
    F --> G[判定是否因 STW 延迟网络就绪响应]

4.4 自定义profile注入与业务指标联动：基于runtime/pprof的内存归属标签化实践

在高并发服务中，原生 runtime/pprof 无法区分内存分配的业务上下文。我们通过 pprof.SetGoroutineLabels() + pprof.Do() 实现运行时标签注入：

// 在HTTP中间件中为请求打标
func profileMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        labels := pprof.Labels(
            "service", "order",
            "endpoint", "/v1/pay",
            "tenant_id", r.Header.Get("X-Tenant-ID"),
        )
        pprof.Do(r.Context(), labels, func(ctx context.Context) {
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    })
}

逻辑分析：pprof.Do() 将标签绑定至当前 goroutine 及其派生子goroutine；runtime.MemStats 不感知标签，但 pprof.Lookup("heap").WriteTo() 输出的堆采样会携带 label 字段（需 Go 1.21+）。关键参数：labels 必须为偶数个字符串键值对，键不可含空格或控制字符。

标签化内存指标映射关系

标签键	示例值	用途
service	"user"	服务域隔离
endpoint	"/login"	接口粒度归因
tenant_id	"t-789"	多租户资源归属追踪

内存分析流程

graph TD
    A[HTTP请求] --> B[中间件注入pprof标签]
    B --> C[业务逻辑分配对象]
    C --> D[pprof heap采样捕获标签]
    D --> E[Prometheus Exporter解析label字段]
    E --> F[按service+endpoint聚合内存RSS]

第五章：从诊断到治理：Go应用内存健壮性工程化闭环

内存问题的典型现场还原

某电商大促期间，订单服务 Pod 持续 OOMKilled，kubectl top pod 显示内存使用在 30 分钟内从 180MB 爆增至 2.1GB。通过 pprof 抓取 heap profile 后发现，sync.Map.Store 调用链下存在未清理的 *http.Request 引用，根源是中间件中将 r.Context() 存入全局 map 且未绑定生命周期——该 Context 携带了整个请求体字节流与 TLS 连接引用，导致 GC 无法回收。

工程化诊断流水线构建

我们落地了一套轻量级内存可观测流水线：

• 每次部署自动注入 -gcflags="-m=2" 编译参数，生成函数逃逸分析日志；
• Prometheus 采集 runtime/metrics 中 /memory/classes/heap/objects:count 和 /memory/classes/heap/unused:bytes；
• Grafana 面板配置告警规则：当 go_memstats_heap_objects_bytes 7 分钟环比增长 >300% 且 go_goroutines 同步上升时触发 P0 告警。

检测阶段	工具链	触发阈值	响应动作
构建期	go build -gcflags="-m=2" + 自研静态分析器	发现 []byte 逃逸至堆且无显式复用	阻断 CI 并标记 PR
运行期	pprof + auto-dump（基于 runtime.SetMemoryLimit）	RSS > 1.5GB 或 5 分钟内增长 >40%	自动抓取 heap/pprof 并上传 S3

生产环境内存泄漏根因定位实录

2024年Q2，支付回调服务出现缓慢内存爬升（日均+12MB）。通过 go tool pprof -http=:8080 http://localhost:6060/debug/pprof/heap?debug=1 实时比对，发现 github.com/golang-jwt/jwt/v5.(*Parser).ParseWithClaims 创建的 jwt.Token 对象持续累积。深入源码发现其 Claims 接口实现未重载 UnmarshalJSON，导致每次解析都新建 map[string]interface{} 而非复用预分配结构体。修复后单实例内存占用从峰值 980MB 降至稳定 210MB。

// 修复前（隐式 map[string]interface{}）
var claims jwt.MapClaims
token, _ := jwt.Parse(string(raw), func(t *jwt.Token) (interface{}, error) {
    return key, nil
})
claims = token.Claims.(jwt.MapClaims) // 每次创建新 map

// 修复后（结构体复用）
type PaymentClaims struct {
    OrderID string `json:"order_id"`
    Amount  int64  `json:"amount"`
    jwt.RegisteredClaims
}
var claims PaymentClaims
token, _ := jwt.ParseWithClaims(string(raw), &claims, func(t *jwt.Token) (interface{}, error) {
    return key, nil
})

治理闭环中的自动化验证机制

在 CI 阶段嵌入内存回归测试：启动服务后模拟 1000 次请求，采集 runtime.ReadMemStats 的 HeapAlloc 与 Mallocs，要求连续三次运行中 HeapAlloc 波动 Mallocs 增量 ≤ 5000。失败则生成 diff 报告并标注新增逃逸函数。

持续防护的运行时守卫

上线 memguardian sidecar，通过 runtime/debug.SetMemoryLimit(1_800_000_000) 设定硬性上限，并监听 runtime.MemStats.NextGC。当检测到下次 GC 时间点距离当前超过 15 秒且 HeapInuse > 1.2GB 时，主动调用 debug.FreeOSMemory() 并记录 trace ID 到 Loki。该机制在灰度期间拦截了 3 起因第三方 SDK 缓存未限容导致的内存雪崩。

flowchart LR
    A[HTTP 请求抵达] --> B{是否含 X-Mem-Guard:true}
    B -->|是| C[注入 runtime.GC() 前置钩子]
    B -->|否| D[常规处理]
    C --> E[采集 MemStats 快照]
    E --> F[对比上一周期 HeapAlloc]
    F -->|Δ > 8MB| G[触发 pprof heap dump]
    F -->|Δ ≤ 8MB| H[放行]