第一章：goroutine泄漏的本质与常见误判陷阱
goroutine泄漏并非指内存被永久占用，而是指本应终止的goroutine持续存活并持有资源（如channel、锁、闭包变量等），导致其栈空间无法回收、CPU持续调度开销累积，最终引发服务性能退化甚至OOM。本质在于控制流失去对goroutine生命周期的终结能力——没有明确的退出信号、缺乏同步等待机制，或错误地将阻塞操作当作“自然结束”。
常见误判陷阱：把阻塞当终止
开发者常误认为 time.Sleep、select {} 或无缓冲channel的发送/接收会“结束”goroutine，实则它们只是挂起执行，goroutine仍处于 waiting 状态并持续驻留内存：
func leakBySleep() {
go func() {
time.Sleep(10 * time.Second) // ❌ 10秒后函数返回，goroutine终止 —— 这是正确行为
fmt.Println("done")
}()
// ✅ 此例不泄漏；但若替换为 select {} 则立即泄漏
}
func leakBySelect() {
go func() {
select {} // ⚠️ 永久阻塞，goroutine永不退出，且无外部唤醒机制 → 泄漏
}()
}通道关闭与接收者的责任错位
向已关闭的channel发送数据会panic，但从已关闭channel接收数据不会阻塞，而是立即返回零值。若接收方未检查 ok 就循环读取，可能陷入空转；更隐蔽的是：发送方关闭channel后，接收方未主动退出，导致goroutine滞留：
| 场景 | 是否泄漏 | 原因 |
|---|---|---|
发送方关闭channel，接收方用 for v := range ch |
否 | range 自动检测关闭并退出循环 |
接收方用 for { v, ok := <-ch; if !ok { break } } |
否 | 显式检查关闭状态 |
接收方用 for { <-ch }（无ok判断） |
是 | channel关闭后仍无限尝试接收，阻塞在 <-ch 上 |
上下文取消失效的典型模式
使用 context.WithCancel 时，若子goroutine未监听 ctx.Done()，或监听后未做清理即返回，则取消信号被忽略：
func leakByIgnoringContext(ctx context.Context) {
go func() {
// ❌ 未 select ctx.Done()，ctx.Cancel() 对此goroutine完全无效
for i := 0; i < 100; i++ {
time.Sleep(time.Millisecond)
fmt.Printf("work %d\n", i)
}
}()
}第二章：go tool trace火焰图的深度解读与实战定位
2.1 火焰图结构解析：G、P、M、goroutine状态跃迁路径识别
火焰图纵轴反映调用栈深度，横轴为采样时间占比；Go 运行时关键实体 G（goroutine）、P（processor）、M（OS thread）的状态变迁在火焰图中呈现为连续块的断裂、嵌套与并行分叉。
goroutine 状态跃迁核心路径
Gwaiting→Grunnable（被唤醒入 P 的 local runq）Grunnable→Grunning（P 抢占 M 执行）Grunning→Gsyscall（系统调用阻塞，M 脱离 P）Gsyscall→Grunnable（sysmon 或 M 完成后归还 G）
关键状态映射表
| 火焰图区块特征 | 对应 G 状态 | 触发条件 |
|---|---|---|
| 独立高幅宽浅层函数块 | Grunning | CPU 密集型执行 |
| 短促中断后接 runtime.futex | Gwaiting | channel 阻塞或 mutex 竞争 |
| 横向分离双峰（M 脱离） | Gsyscall | read/write 系统调用阻塞 |
// runtime/proc.go 中状态跃迁关键逻辑（简化）
func goready(gp *g, traceskip int) {
status := readgstatus(gp)
if status&^_Gscan != _Gwaiting { // 必须处于等待态才可就绪
throw("goready: bad g status")
}
casgstatus(gp, _Gwaiting, _Grunnable) // 原子切换至可运行态
runqput(_g_.m.p.ptr(), gp, true) // 入 P 本地队列
}该函数确保仅 _Gwaiting 状态的 goroutine 可被安全激活；runqput 的 true 参数启用尾插以维持公平性，避免饥饿。火焰图中对应“唤醒尖峰”即源于此路径。
graph TD
A[Gwaiting] -->|channel receive| B[Grunnable]
B -->|P 调度| C[Grunning]
C -->|syscall| D[Gsyscall]
D -->|sysmon 检测完成| B
C -->|chan send block| A2.2 关键事件标记实践：trace.Start/Stop埋点与自定义用户事件注入
Go 的 runtime/trace 提供轻量级运行时追踪能力，trace.Start() 与 trace.Stop() 构成基础埋点生命周期。
启动与终止追踪
import "runtime/trace"
func main() {
f, _ := os.Create("trace.out")
defer f.Close()
trace.Start(f) // 启动全局追踪器，采集 goroutine、network、syscall 等事件
defer trace.Stop() // 必须调用，否则 trace 文件不完整且资源泄漏
}trace.Start() 接收 io.Writer，内部启用多路事件采集协程；trace.Stop() 原子关闭采集并刷盘元数据。
注入自定义用户事件
trace.Log(ctx, "auth", "user_id=1001, role=admin") // 标记业务上下文
trace.WithRegion(ctx, "payment_processing", func() {
processPayment()
})trace.Log() 写入带标签的字符串事件；trace.WithRegion() 创建可嵌套的命名执行区间，支持 UI 工具高亮渲染。
常见事件类型对比
| 事件类型 | 触发时机 | 是否需手动管理 |
|---|---|---|
trace.Start/Stop |
全局追踪开关 | 是 |
trace.Log |
任意业务点打标 | 否 |
trace.WithRegion |
代码块级耗时与嵌套分析 | 否（自动配对） |
graph TD
A[trace.Start] --> B[采集 runtime 事件]
A --> C[注册用户事件钩子]
B & C --> D[trace.Stop → 生成 trace.out]2.3 泄漏goroutine特征捕获：持续阻塞在chan send/recv、timer、netpoll中的可视化判据
常见阻塞态可观测信号
Go 运行时通过 runtime.Stack() 或 /debug/pprof/goroutine?debug=2 可暴露 goroutine 当前状态，关键阻塞标记包括：
chan send/chan recv（无缓冲通道且无配对协程）selectgo（空select{}或全 channel 阻塞）timerSleep/timerProc（未触发的time.After或time.Ticker）netpollwait（阻塞在conn.Read/Write且连接未关闭）
典型泄漏模式代码示例
func leakByUnbufferedChan() {
ch := make(chan int) // 无缓冲
go func() {
<-ch // 永久阻塞：无 sender
}()
// ch 从未被写入 → goroutine 泄漏
}逻辑分析：该 goroutine 在
runtime.gopark中进入chan receive状态，g.status == _Gwaiting，且g.waitreason == "chan receive"。pprof 中持续显示为runtime.gopark → runtime.chanrecv → main.leakByUnbufferedChan·1，是强泄漏判据。
可视化判据对照表
| 阻塞场景 | pprof 状态字段 | 是否可被 go tool trace 捕获 |
|---|---|---|
| chan recv (无配对) | chan receive |
✅（在 Goroutine Analysis 视图中标红） |
time.Sleep(1h) |
timerSleep |
✅（关联 timer heap 分析） |
http.ListenAndServe |
netpollwait |
⚠️（需结合连接生命周期追踪） |
graph TD
A[goroutine 阻塞] --> B{阻塞类型}
B -->|chan send/recv| C[检查通道缓冲与配对操作]
B -->|timerSleep| D[检查 Timer/Ticker 是否 Stop]
B -->|netpollwait| E[检查 conn.Close 调用路径]2.4 多goroutine竞争热点定位：通过goroutine ID关联与栈帧聚合发现共享资源争用链
数据同步机制
Go 运行时暴露 runtime.Stack() 和 debug.ReadGCStats()，但需主动注入 goroutine ID（goid）以建立跨调度的追踪锚点：
func withGoroutineID(fn func()) {
g := getg() // 获取当前 g 结构体指针
goid := *(*uint64)(unsafe.Pointer(uintptr(g) + 152)) // Go 1.22+ offset
ctx := context.WithValue(context.Background(), "goid", goid)
trace.Log(ctx, "acquire_lock", "key", "config_mutex")
fn()
}此代码通过
unsafe提取运行时私有字段g.goid（偏移量依 Go 版本而异），为后续栈帧打标提供唯一上下文标识。注意：该偏移非 ABI 稳定，生产环境应使用runtime/debug.Stack()配合正则提取 ID。
争用链聚合策略
对采集的数千条栈迹按 goid → lock_key → caller_func 三元组归一化后，构建资源争用图：
| goid | lock_key | depth | caller |
|---|---|---|---|
| 1023 | config_mutex | 3 | LoadConfig |
| 2108 | config_mutex | 4 | ValidateSchema |
graph TD
A[goroutine-1023] -->|holds| B[config_mutex]
C[goroutine-2108] -->|waits| B
D[goroutine-3091] -->|waits| B
B --> E[shared Config struct]2.5 火焰图与pprof互证：从trace导出goroutine profile并交叉验证泄漏根因
当 runtime/trace 捕获到持续增长的 goroutine 数量时，需进一步定位阻塞源头。可通过 go tool trace 提取实时 goroutine profile：
# 从 trace 文件中导出 goroutine profile（采样点为 trace 中的 GoroutineStatus 事件）
go tool trace -http=localhost:8080 trace.out
# 在 Web UI 中点击 "Goroutine analysis" → "Download goroutine profile"
# 或直接用 pprof 解析（需 trace 工具支持）：
go tool pprof -http=:8081 -symbolize=none goroutines.pb.gz该命令触发 pprof 对 trace 内嵌的 goroutine 快照做聚合分析，-symbolize=none 避免符号解析延迟，适用于无调试信息的生产环境。
交叉验证关键指标
| 视角 | 关注点 | 异常信号 |
|---|---|---|
| 火焰图 | runtime.gopark 占比陡增 |
goroutine 集中阻塞 |
| goroutine profile | net/http.(*conn).serve 持久存活 |
HTTP 连接未关闭 |
验证流程
graph TD
A[trace.out] --> B[提取 goroutine 快照]
B --> C[pprof 分析堆栈分布]
C --> D[火焰图对齐 runtime.gopark 调用链]
D --> E[定位未释放的 channel recv/send]核心逻辑：trace 提供时间维度的 goroutine 生命周期事件，pprof goroutine 提供快照态堆栈分布，二者叠加可排除瞬时抖动，锁定长期驻留的泄漏 goroutine。
第三章：GODEBUG=schedtrace=1000调度器日志的精读方法论
3.1 调度器输出字段语义解码：SCHED、GOMAXPROCS、GRQ、LRQ、RUNQUEUE等核心指标含义
Go 运行时调度器通过 runtime.GoroutineProfile 和调试接口（如 GODEBUG=schedtrace=1000）输出关键调度状态字段，理解其语义是性能调优的基石。
核心字段语义对照表
| 字段 | 含义说明 | 典型值示例 |
|---|---|---|
SCHED |
全局调度器实例数（通常为1） | SCHED 1 |
GOMAXPROCS |
当前 P 的最大数量（即 OS 线程可并行执行的 P 数） | GOMAXPROCS=8 |
GRQ |
全局 Goroutine 队列长度（全局可运行队列） | GRQ 12 |
LRQ |
当前 P 的本地运行队列长度 | LRQ 5 |
RUNQUEUE |
所有 P 的本地队列长度总和（含 GRQ） | RUNQUEUE 47 |
调度状态快照示例分析
SCHED 123456: gomaxprocs=8 idleprocs=1 threads=15 spinningthreads=1 idlethreads=5 runqueue=47
P0: status=1 schedtick=123456 syscalltick=0 m=30 goid=123456 runqsize=5
P1: status=1 schedtick=123455 syscalltick=0 m=31 goid=123457 runqsize=3
runqsize=5即LRQ，表示 P0 本地队列有 5 个待运行 goroutine；runqueue=47是GRQ + Σ(LRQ)的聚合值，反映整体就绪负载。idleprocs=1暗示存在空闲 P，可能因 I/O 阻塞或任务不均导致资源闲置。
调度流转逻辑示意
graph TD
A[New Goroutine] --> B{P.localRunq 是否有空位？}
B -->|是| C[入 LRQ 尾部]
B -->|否| D[溢出至 GRQ]
C & D --> E[Work-Stealing：空闲 P 从其他 P.LRQ 或 GRQ 偷取]3.2 泄漏模式日志指纹识别：goroutine数量单边增长+P本地队列长期非空+全局队列积压的三重信号
当 Go 程序持续运行中出现性能劣化，需结合运行时指标交叉验证泄漏特征：
三重信号协同判定逻辑
- goroutine 数量单边增长：
runtime.NumGoroutine()持续上升且无回落； - P 本地队列长期非空：通过
debug.ReadGCStats无法直接获取，需借助pprof或runtime调试接口读取p.runqsize； - 全局队列积压：
runtime.GOMAXPROCS(0)对应的sched.runqsize显著 > 100（阈值依负载而定）。
典型日志指纹示例
// 采集周期性指标（每5秒）
func logFingerprint() {
n := runtime.NumGoroutine()
sched := readSchedStats() // 需通过 unsafe 或 go:linkname 获取
fmt.Printf("g:%d, runq_g:%d, runq_p:%v\n",
n, sched.runqsize, sched.pRunqSizes) // pRunqSizes []uint64
}此函数依赖
runtime内部符号导出；runq_p是各 P 的本地队列长度切片，长期 > 0 表明任务未被及时消费。
信号组合判据表
| 信号维度 | 健康阈值 | 泄漏嫌疑标志 |
|---|---|---|
| goroutine 总数 | 波动 ≤ ±5% | 单调增长 ≥ 30min |
| 单个 P 本地队列 | 平均 ≤ 2 | 连续 10 次采样 ≥ 8 |
| 全局队列长度 | > 200 且持续 5+ 周期 |
graph TD
A[采集指标] --> B{g数量↑?}
B -->|是| C{P本地队列长期非空?}
B -->|否| D[排除泄漏]
C -->|是| E{全局队列积压?}
E -->|是| F[触发泄漏告警]
E -->|否| D3.3 结合runtime.ReadMemStats验证：Goroutines计数与schedtrace趋势一致性校验
数据同步机制
runtime.ReadMemStats 中的 NumGoroutine 字段是原子快照，而 GODEBUG=schedtrace=1000 输出的 goroutine 数值来自调度器锁保护下的瞬时统计。二者非严格实时一致，但长期趋势应高度吻合。
验证代码示例
var m runtime.MemStats
for i := 0; i < 5; i++ {
runtime.GC()
runtime.ReadMemStats(&m)
fmt.Printf("MemStats.NumGoroutine: %d\n", m.NumGoroutine)
time.Sleep(1 * time.Second)
}该循环每秒采集一次 NumGoroutine，规避 GC 干扰；runtime.GC() 强制清理终结器 goroutine，提升对比纯净度。
关键差异对照表
| 来源 | 更新时机 | 线程安全性 | 延迟典型值 |
|---|---|---|---|
ReadMemStats |
GC 或手动触发 | ✅ 原子读 | ~10–100ms |
schedtrace |
每次调度器 tick | ✅ 锁保护 |
趋势一致性判定逻辑
graph TD
A[启动 schedtrace=1000] --> B[采集 MemStats.NumGoroutine]
B --> C[滑动窗口计算斜率]
C --> D{斜率符号一致？}
D -->|是| E[通过一致性校验]
D -->|否| F[检查阻塞/泄漏嫌疑]第四章：双工具协同分析的5分钟标准化排查流程
4.1 快速采集黄金组合：trace启动时机选择（warmup后+业务高峰期）与schedtrace采样频率调优
启动时机的双重约束
JVM 预热（warmup）完成后，类加载、JIT 编译、缓存填充趋于稳定；此时启动 trace 可规避噪声干扰。业务高峰期则保障样本具备真实负载代表性——二者叠加构成黄金采集窗口。
schedtrace 频率调优策略
过高采样（如 100μs）引发可观测性开销飙升；过低（如 10ms）则丢失短时调度抖动。推荐起始值：500μs，结合 perf record -e sched:sched_switch -F 2000 验证吞吐与精度平衡。
# 启动脚本示例：warmup 后延迟 30s 进入高峰期再采样
sleep 30 && \
perf record -e sched:sched_switch -F 2000 -g --call-graph dwarf -o trace.perf -- sleep 60逻辑说明：
-F 2000表示每秒采样 2000 次（即周期 ≈ 500μs）；--call-graph dwarf启用精准栈回溯；sleep 60确保覆盖完整业务高峰段。
推荐参数对照表
| 场景 | 采样频率 | 适用性 | 开销估算 |
|---|---|---|---|
| 微服务高频调度诊断 | 2000 Hz | ★★★★☆ | ~3% CPU |
| 批处理长任务分析 | 200 Hz | ★★★☆☆ |
graph TD
A[Warmup完成] --> B{系统稳定？}
B -->|Yes| C[等待业务高峰]
C --> D[启动schedtrace]
D --> E[按2000Hz采样60s]4.2 漏洞定位四步法：时间轴对齐→goroutine生命周期追踪→阻塞点栈回溯→源码行级锚定
时间轴对齐：多维事件归一化
使用 pprof 与 trace 工具输出的时间戳需统一到纳秒级单调时钟，避免系统时钟跳变干扰。关键参数：
go tool trace -http=:8080 app.trace # 启动交互式时间线视图该命令加载 trace 文件并暴露 Web UI，底层依赖 runtime/trace 的 Event 时间戳（基于 nanotime()），确保与 pprof CPU/heap profile 时间轴严格对齐。
goroutine 生命周期追踪
通过 runtime.ReadMemStats + debug.ReadGCStats 关联 GC 周期与 goroutine 爆炸点；核心指标见下表：
| 指标 | 含义 | 健康阈值 |
|---|---|---|
Goroutines |
当前活跃 goroutine 数 | |
NumGC |
GC 次数 | 突增预示泄漏或阻塞 |
阻塞点栈回溯
执行 go tool pprof -http=:8081 cpu.pprof 后点击「Flame Graph」→ 右键「Show blocked goroutines」，自动高亮 semacquire、chan receive 等阻塞调用栈。
源码行级锚定
// 示例：定位 channel 阻塞的精确行号
ch := make(chan int, 1)
ch <- 1 // Line 5: 正常
ch <- 2 // Line 6: 阻塞！pprof 栈将指向此行runtime.gopark 在阻塞时记录 pc（程序计数器），经 DWARF 符号解析后映射至 .go 文件具体行号，实现毫秒级定位闭环。
4.3 常见泄漏场景速查表：http.HandlerFunc未关闭response.Body、context.WithTimeout未defer cancel、time.AfterFunc未清理timer
HTTP 响应体泄漏
未关闭 resp.Body 会导致底层连接无法复用，堆积 idle connections：
func handler(w http.ResponseWriter, r *http.Request) {
resp, _ := http.Get("https://api.example.com/data")
defer resp.Body.Close() // ✅ 正确：确保关闭
// ... 处理逻辑
}⚠️ 若漏掉 defer resp.Body.Close()，net/http 不会自动释放底层 *http.http2Transport 连接，引发 http: persistent connection broken 风险。
Context 超时未取消
context.WithTimeout 创建的 cancel 函数必须显式调用，否则 goroutine 泄漏：
func handleWithCtx(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel() // ✅ 必须 defer，否则子 goroutine 持有 ctx 引用不释放
select {
case <-ctx.Done():
http.Error(w, "timeout", http.StatusRequestTimeout)
}
}Timer 清理对比
| 场景 | 是否需手动清理 | 原因 |
|---|---|---|
time.AfterFunc(d, f) |
✅ 是 | 返回无引用 timer，无法 Stop |
time.NewTimer(d) |
✅ 是 | 必须 t.Stop() 防止已触发 timer 仍执行 |
graph TD
A[启动 AfterFunc] --> B[Timer 内部启动 goroutine]
B --> C{是否触发？}
C -->|是| D[执行回调]
C -->|否| E[goroutine 持续等待至超时]
E --> F[无法回收 → 泄漏]4.4 自动化辅助脚本：基于go tool trace解析器提取goroutine创建/阻塞/退出事件流并生成泄漏嫌疑排名
核心设计思路
脚本以 go tool trace 输出的二进制 trace 文件为输入，利用 Go 官方 golang.org/x/tools/go/trace 包构建轻量解析器，跳过完整 UI 渲染路径，直取 GoroutineCreate、GoBlock、GoUnblock、GoroutineEnd 四类关键事件。
关键处理逻辑（Go 示例）
// 提取未结束的 goroutine ID 集合（潜在泄漏候选）
active := make(map[uint64]time.Time)
for _, ev := range events {
switch ev.Type {
case trace.EvGoCreate:
active[ev.Goroutine] = ev.Ts // 记录创建时间戳（纳秒）
case trace.EvGoEnd:
delete(active, ev.Goroutine) // 正常退出即移除
}
}逻辑分析：仅保留
EvGoCreate后无对应EvGoEnd的 goroutine；ev.Ts为单调递增纳秒时间戳，用于后续按存活时长排序。ev.Goroutine是唯一 uint64 ID，非 OS 线程 ID。
泄漏嫌疑排名依据
| 指标 | 权重 | 说明 |
|---|---|---|
| 存活时长（Δt） | 40% | now - createTs，越长越可疑 |
| 阻塞次数 | 35% | count(EvGoBlock) |
| 是否在系统栈运行 | 25% | ev.Stack 中含 runtime. 前缀则降权 |
事件流处理流程
graph TD
A[trace.bin] --> B[ParseEvents]
B --> C{Filter by Type}
C --> D[Build Goroutine Lifecycle Map]
D --> E[Rank by Δt + BlockCount]
E --> F[Top-K Suspicious IDs]第五章：从定位到修复的工程闭环与防御性编码规范
在真实生产环境中，一次线上支付失败的故障追踪成为本章的起点：用户提交订单后返回 500 Internal Server Error，日志中仅显示 NullPointerException at PaymentService.process()。团队通过链路追踪（SkyWalking）定位到 OrderContext.getCustomer().getPreferredCurrency() 调用处空指针，而该对象在异步消息消费路径中未被完整初始化。
故障复现与根因深挖
开发人员在本地复现时发现：Kafka 消费者反序列化 OrderEvent 后，调用 CustomerLoader.loadById() 时因缓存穿透返回 null，但业务代码未做判空即链式调用。根本原因并非逻辑错误，而是缺乏对第三方服务降级契约的显式建模——CustomerLoader 接口文档明确标注“可能返回 null”，但调用方未遵循防御性契约。
工程闭环四阶段实践
| 阶段 | 关键动作 | 工具链示例 |
|---|---|---|
| 定位 | 基于 OpenTelemetry 的 span 标签过滤 + 日志上下文 ID 关联 | Jaeger + ELK + Grafana |
| 验证 | 编写可复现的单元测试（含 Mock 异常分支）+ Chaos Mesh 注入网络延迟 | JUnit 5 + Mockito + Kubernetes |
| 修复 | 采用 Optional<Customer> 替代裸引用 + 添加 @NonNull 注解驱动静态检查 |
Lombok + SpotBugs + Gradle Check |
| 防御 | 在 API 网关层注入统一空值熔断规则 + 为 CustomerLoader 添加 CircuitBreaker |
Spring Cloud Gateway + Resilience4j |
防御性编码核心规范
- 所有外部服务调用必须包裹
try-catch或使用CompletableFuture.exceptionally()显式处理； - DTO 层禁止使用原始类型（如
int），强制使用包装类（如Integer）并配合@NotNull和@Min(1)校验； - 数据库查询结果必须通过
Objects.requireNonNullElse()提供默认值，禁止直接调用list.get(0)； - REST 接口响应体统一封装为
Result<T>，其中code字段严格遵循200/400/500三级分类，禁止混用422 Unprocessable Entity与500表达业务校验失败。
// 修复后关键代码片段
public Result<PaymentReceipt> process(OrderContext context) {
Customer customer = Optional.ofNullable(context.getCustomer())
.or(() -> Optional.ofNullable(customerLoader.loadById(context.getCustomerId())))
.orElseThrow(() -> new BusinessException("CUSTOMER_NOT_FOUND", "客户信息缺失"));
return Result.success(paymentProcessor.execute(
new PaymentRequest(customer.getPreferredCurrency(), context.getAmount())
));
}闭环验证自动化流水线
flowchart LR
A[触发告警] --> B[自动拉取最近3次失败trace]
B --> C[提取异常堆栈特征]
C --> D[匹配预设修复模板]
D --> E[生成带测试用例的PR]
E --> F[CI执行Mutation Test覆盖率≥85%]
F --> G[合并至release分支]该闭环已在支付域落地127次故障修复，平均MTTR从47分钟降至6.3分钟。所有新接入服务必须通过 DefensiveCodeCheck 插件扫描，该插件基于 ASM 动态分析字节码，拦截未处理的 NullPointerException、ArrayIndexOutOfBoundsException 及未关闭的 Closeable 资源。
