1
2
3
4
5
6
7

物理 RAM
├─ 进程工作集
├─ 系统/内核
├─ 文件缓存
├─ 内存压缩
├─ 驱动占用
└─ 其他可回收/不可回收内存

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

内存异常
  │
  ├─ 是整机卡，还是单个程序卡？
  │
  ├─ 重启后恢复吗？
  │
  ├─ 内存是持续上涨，还是瞬间上涨？
  │
  ├─ 哪个进程在涨？
  │
  ├─ 进程涨的是 Working Set / Private Memory / Commit 哪一种？
  │
  ├─ 总内存是否接近物理 RAM 上限？
  │
  ├─ Commit 是否接近 Commit Limit？
  │
  ├─ Pagefile 是否持续高负载？
  │
  └─ 如果进程加起来不高：
       ├─ 查缓存/Standby
       ├─ 查内存压缩
       ├─ 查内核/驱动
       └─ 查非分页池/分页池

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

第 1 步：确认现象
第 2 步：记录基线
第 3 步：确认系统压力
第 4 步：找最大消费者
第 5 步：看它是不是持续增长
第 6 步：区分是哪一种内存
第 7 步：判断是正常需求还是泄漏
第 8 步：临时恢复
第 9 步：长期修复
第 10 步：验证修复是否有效

1

电脑安装 32 GB RAM

1

永远有 32 GB 可以随便用

1
2
3
4

Ctrl + Shift + Esc
→ 任务管理器
→ 性能
→ 内存

1
2
3
4
5
6
7

已使用
可用
提交
缓存
分页池
非分页池
速度

1
2

Get-CimInstance Win32_OperatingSystem |
Select-Object TotalVisibleMemorySize,FreePhysicalMemory

1
2

KB ÷ 1024 = MB
MB ÷ 1024 = GB

1
2
3

Chrome.exe      8 GB
某业务程序.exe  12 GB
数据库服务      10 GB

1
2
3

任务管理器
→ 进程
→ 点击“内存”排序

1
2
3
4

Get-Process |
Sort-Object WorkingSet64 -Descending |
Select-Object -First 20 Name,Id,
@{N='WorkingSetGB';E={[math]::Round($_.WorkingSet64/1GB,2)}}

1
2
3
4

程序本来就需要大量内存
内存占用稳定
业务量增加时合理增长
业务结束后能够下降

1
2
3
4

程序空闲时仍持续上涨
重启程序后立即恢复
运行时间越长越大
无业务变化但内存不断增长

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

程序申请内存
   ↓
使用内存
   ↓
本来应该释放
   ↓
没有释放
   ↓
继续申请
   ↓
越来越大

1
2
3
4
5

10:00  500 MB
10:30  900 MB
11:00  1.8 GB
11:30  3.5 GB
12:00  6.7 GB

1
2
3

程序启动：2 GB
加载数据：8 GB
之后稳定：8 GB

1
2
3
4

程序启动：2 GB
10分钟：3 GB
20分钟：4 GB
30分钟：5 GB

1
2

Private Bytes
一直上涨

1
2

Commit Charge
Commit Limit

1
2

Commit = 30 GB
Commit Limit = 32 GB

1
2
3

性能
→ 内存
→ 已提交

1
2
3
4

任务管理器
→ 详细信息
→ 选择列
→ 提交大小

1
2
3
4
5
6

系统属性
→ 高级
→ 性能
→ 设置
→ 高级
→ 虚拟内存

1
2

Commit 是否接近 Limit
系统是否持续发生严重分页

1
2
3

RAM 64 GB
应用实际只需要 20 GB
系统可能仍把大量 RAM 放进缓存

1

性能 → 内存

1

内存压缩

1
2
3

任务管理器中没有任何一个程序特别夸张
但是：
总内存越来越高

1
2
3
4
5
6
7
8

驱动
内核组件
杀毒软件
VPN驱动
网卡驱动
显卡驱动
文件系统过滤驱动
虚拟化组件

1
2

性能
→ 内存

1
2

分页池
非分页池

1

非分页池不断增长

1

分页池长期不断增长

1

poolmon.exe

1
2
3

Tag
Bytes
Allocations

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

发现总内存持续增长
 ↓
普通进程加起来不高
 ↓
非分页池明显增长
 ↓
运行 PoolMon
 ↓
找到持续增长的 Tag
 ↓
把 Tag 映射到驱动
 ↓
更新/回滚/卸载对应驱动
 ↓
重新观察

1

Handles

1
2
3

详细信息
→ 选择列
→ 句柄

1
2
3

程序启动：2,000 handles
1小时：30,000
2小时：80,000

1
2

GDI Objects
USER Objects

1
2

详细信息
→ 选择列

1
2
3
4

对象是否持续增长
堆是否持续增长
分配速度是否持续增长
GC 后是否仍持续上升

1

某软件内存随时间持续增长

1
2
3
4
5
6
7
8
9

启动程序
↓
执行固定操作
↓
等待
↓
重复
↓
记录内存

1
2
3
4

循环打开/关闭窗口 100 次
循环加载/卸载文件 100 次
循环登录/退出 100 次
循环创建/关闭连接

1

每轮操作 + 10 MB

1
2
3
4

AddressSanitizer
Valgrind
Visual Studio Diagnostic Tools
Application Verifier

1
2
3
4
5

Heap
Old Gen
Metaspace
Direct Buffer
Thread

1
2
3
4
5
6

jcmd
jmap
jstack
JFR
MAT
VisualVM

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Heap 不断增长
 ↓
Full GC 后仍下降不下来
 ↓
Dump
 ↓
MAT 看 Dominator Tree
 ↓
找最大 Retained Size
 ↓
找引用链

1
2
3
4

Managed Heap
Gen 0 / Gen 1 / Gen 2
LOH
GC

1
2
3
4
5

dotnet-counters
dotnet-dump
dotnet-gcdump
PerfView
Visual Studio

1
2
3
4
5
6

对象数量
容器增长
全局变量
缓存
循环引用
C 扩展

1
2
3
4

tracemalloc
gc
objgraph
memory_profiler

1
2
3

进程内存
线程数
句柄

1
2
3

Get-Process |
Sort-Object Threads -Descending |
Select-Object -First 20 Name,Id,Threads

1
2
3
4
5
6

文件
Socket
数据库连接
线程
Timer
Handle

1
2
3
4
5
6
7

内存
+
句柄
+
线程
+
连接数

1
2

启动 → 8 GB
之后稳定

1

1 GB → 2 → 3 → 4 → 5 GB

1
2
3
4
5
6
7
8
9

2 GB
↓
加载大文件
↓
10 GB
↓
操作结束
↓
9.8 GB

1
2
3
4
5
6
7

2 GB
↓
处理大数据
↓
30 GB
↓
OOM

1
2
3
4

事件查看器
→ Windows 日志
→ 应用程序
系统

1
2
3

Application Error
Resource-Exhaustion-Detector
Kernel-Power

1
2
3
4

时间
进程
故障模块
内存压力

1
2
3

事件查看器
→ Windows 日志
→ 系统

1

Resource-Exhaustion-Detector

1

perfmon

1
2
3
4
5
6
7

Memory\Available MBytes
Memory\% Committed Bytes In Use
Paging File\% Usage
Process(*)\Private Bytes
Process(*)\Working Set
Process(*)\Handle Count
Process(*)\Thread Count

1
2
3
4
5

结束异常进程
重启服务
重启程序
重启电脑
清理无用任务

1

把内存清空

1
2
3
4
5
6
7

复现
→ 抓内存快照
→ 找增长对象
→ 找引用链
→ 修改代码
→ 压测
→ 长时间运行

1
2
3
4
5
6

找 Pool Tag
→ 对应驱动
→ 更新驱动
→ 回滚驱动
→ 卸载相关软件
→ 验证

1
2
3
4

缓存上限没设置
JVM Heap过大
数据库 Buffer 配置过大
容器限制不合理

1
2
3
4
5
6
7
8
9

监控
+
告警
+
限制
+
自动重启
+
泄漏修复

1
2
3
4

内存 > 70% → 告警
内存 > 80% → 检查异常进程
内存 > 90% → 触发保护
内存 > 95% → 按策略重启非核心服务

1
2
3
4
5
6
7

1. 保存能保存的数据
2. 找异常进程
3. 停止非核心大内存程序
4. 如果系统已经无法操作：
   → Ctrl + Alt + Del
   → 任务管理器
5. 最后才考虑重启

1

free -h

1
2
3
4
5
6

total
used
free
buff/cache
available
swap

1

ps aux --sort=-%mem | head

1

watch -n 2 free -h

1

watch -n 2 'ps -eo pid,comm,%mem,rss --sort=-rss | head -20'

1

swapon --show

1

dmesg | grep -i oom

1

journalctl -k | grep -i oom

1
2

Out of memory
Killed process

1
2

宿主机有 64 GB
Docker 容器只有 2 GB 限制

1

docker stats

1
2
3

MEM USAGE
MEM %
LIMIT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

Java进程越来越大
 ↓
看 Heap
 ↓
Full GC 后是否回落
 ↓
不回落
 ↓
Heap Dump
 ↓
MAT
 ↓
Dominator Tree
 ↓
Retained Size
 ↓
找引用链

1

OutOfMemoryError

1
2
3
4
5
6

Heap OOM
Metaspace OOM
Direct Memory OOM
Native Memory OOM
Address Space OOM
Container Memory Limit

1
2
3

8:00 正常
12:00 开始卡
15:00 内存 95%

1
2
3

任务管理器排序
→ 每30分钟记录内存
→ 找出增长最快进程

1
2
3
4
5
6
7

总内存
↓
进程总和
↓
非分页池/分页池
↓
驱动

1
2

Nonpaged Pool
持续上涨

1
2
3

Available
Cached
Commit

1
2
3
4
5
6
7

重启服务
↓
内存恢复
↓
继续运行
↓
再次增长

1
2
3

Commit
Pagefile
Kernel

1
2

500 MB 文件
→ 程序读取成 8 GB 对象

1
2
3
4

流式读取
分页处理
分块处理
减少中间副本

1
2
3
4
5

浏览器
→ 标签页
→ 扩展
→ GPU进程
→ 单个网页

1

浏览器自身任务管理器

1
2
3
4
5
6
7

性能计数器
+
进程 Private Bytes
+
Handle Count
+
Thread Count

1
2

升级前
升级后

1

docker stats

1

容器使用 > limit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

内存高 ≠ 内存泄漏

持续上涨 → 查泄漏
重启恢复 → 看生命周期
单进程高 → 查进程
总量高、进程不高 → 查内核/缓存
Commit 高 → 查虚拟内存
Pagefile 重 → 查分页压力
Nonpaged Pool 高 → 查驱动
Handle 高 → 查资源泄漏
Thread 高 → 查线程泄漏
瞬间暴涨 → 查峰值分配
容器 OOM → 查容器限制

1

关闭页面文件

1

为了“释放内存”频繁运行所谓内存清理工具

1

不知道进程是什么就 taskkill

1

生产环境直接重启

1

把重启当成泄漏修复

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

时间：

故障现象：

物理内存总量：

已用：

可用：

Commit：

Pagefile：

最大进程：

最大进程内存：

进程 Private Memory：

Working Set：

Nonpaged Pool：

Paged Pool：

Handles：

Threads：

是否重启恢复：

恢复后多久再次出现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

【基本信息】

机器：
系统：
RAM：
程序：
版本：

【故障】

开始时间：
发生频率：
是否可复现：

【初始状态】

总内存：
可用：
Commit：
Pagefile：

【进程】

PID：
进程：
Working Set：
Private Memory：
Commit：
Handles：
Threads：

【变化】

10:00：
10:30：
11:00：
11:30：
12:00：

【判断】

问题类型：
怀疑层级：
怀疑对象：

【处理】

临时措施：

永久措施：

【验证】

运行多久：
是否再次增长：
增长速度：
是否达到原来的峰值：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

① 看总内存
   ↓
② 看可用内存
   ↓
③ 看 Commit
   ↓
④ 按进程内存排序
   ↓
⑤ 找最大的进程
   ↓
⑥ 记录它的 Working Set / Private Memory
   ↓
⑦ 观察 10~30 分钟
   ↓
⑧ 判断“稳定高”还是“持续涨”
   ↓
⑨ 如果持续涨：
       查泄漏
   如果进程不涨：
       查缓存/内核/驱动
   如果 Commit 爆：
       查虚拟内存
   如果瞬间爆：
       查峰值分配
   如果容器爆：
       查限制
   ↓
⑩ 临时恢复
   ↓
⑪ 找根因
   ↓
⑫ 修改
   ↓
⑬ 长时间验证

1
2
3
4
5
6
7

谁占了内存？
占了多少？
占的是哪种内存？
为什么占？
是否持续增长？
是否可以释放？
如何证明修好了？