凌晨三点进程被杀:先认清是谁动的手
那天凌晨三点,监控告警说 PHP-FPM 挂了,重启之后又好了。白天查 /var/log/php-fpm.log 什么也没有,Nginx 的 error_log 里只有一堆 502。如果只翻应用日志,这件事就查不下去了——因为动手的不是应用,也不是 Nginx,是内核。
Linux 内存不足时,内核有一个保底机制叫 OOM killer(Out Of Memory killer)。它的工作方式非常粗暴:在内存真的分配不出来的时候,挑一个进程,直接 SIGKILL。进程没机会写日志、没机会优雅退出、也没机会告诉你它被杀了。所以这类故障的第一个特征就是:日志里找不到这个进程的崩溃原因。
这篇记录的是我从「以为是 PHP 的 bug」到「能定量算出内存预算」的完整排查路径。它和 swap 抖动不是一回事:swap 抖动是内存紧但还没到杀人的地步,系统慢得像卡死;OOM 是已经杀完了,系统反而「正常」了,只是少了个进程。
第一个证据:内核日志里的 OOM 记录
只要真的发生过 OOM kill,内核一定留下了记录。它不在应用日志里,在以下三个地方之一:
# 1. dmesg(本次开机以来的内核环形缓冲)
dmesg -T | grep -i -E 'killed process|out of memory'
# 2. 内核日志文件(Debian/Ubuntu 默认在 syslog 或 kern.log)
grep -i -E 'oom|killed process' /var/log/kern.log /var/log/syslog
# 3. systemd-journald(如果用了 journald 接管内核日志)
journalctl -k --since '3 days ago' | grep -i 'killed process'命中的那几行信息量很大,逐字段读:
Out of memory: Killed process 18342 (php-fpm) total-vm:2103456kB,
anon-rss:1820340kB, file-rss:1024kB, shmem-rss:0kB, UID:33 pgtables:3720kB
oom_score_adj:0要点:total-vm 是虚拟内存,通常很大且没意义(PHP 进程虚拟内存动辄 1.5G 是正常的,别被吓到);要看的是 anon-rss,也就是真正驻留的匿名内存,1.8G——这才是它吃掉的实际物理内存。UID:33 是 www-data,说明被杀的是 Web 子进程。
再往前翻几行,会看到一张「内存总账」:
Mem-Info:
active_anon:712345 inactive_anon:203456 isolated_anon:0
active_file:201234 inactive_file:310456 ...
Node 0 DMA32 free:23456kB min:23456kB low:29320kB high:35184kB
Node 0 Normal free:12345kB min:12345kB low:15431kB high:18517kB
lowmem_reserve[]: 0 0 0 0
Node 0 DMA32: 12345*4kB (UE) ... = 49380kB
slab_reclaimable:120345kB slab_unreclaimable:34012kB
free 已经掉到 min 水位以下,说明整个节点(NUMA node)都缺水了,才会触发全局 OOM。这一句是判据:如果 free 还在 min 之上却仍然 OOM,那多半是 cgroup 或 memcg 限制触发的,属于容器层面的事,得换个方向查(后面会讲)。
为什么老是它被杀:oom_score 的算法
OOM killer 不是随机挑,它按分数挑最高的。分数的核心是这一行(内核源码 oom_badness() 的语义):
oom_score ≈ 进程占用的物理内存 (rss+swapents) / 系统总内存 × 1000 + oom_score_adj
也就是说,谁吃得多谁先死。这解释了一个常见困惑:「为什么每次都是 PHP-FPM 的子进程被杀,MySQL 却活得好好的?」因为 MySQL 的 buffer pool 占用了 2G 内存,但它是 master 进程、长连接、RSS 稳定,而 PHP 在高峰期会 fork 出几十个子进程,每个都涨到几百兆,加起来瞬间超过 MySQL。总量第一的那个就被挑走了。
调节参数有两个,在 /proc/,取值 -1000 到 1000(-1000 表示永不杀):
# 看所有进程的 oom_score(需要在系统紧张时才有意义)
for p in /proc/[0-9]*; do
pid=${p#/proc/}
[ -r "$p/oom_score" ] || continue
s=$(cat "$p/oom_score" 2>/dev/null)
[ -n "$s" ] && [ "$s" -gt 0 ] && printf '%6s %6s %s\n' "$s" "$pid" "$(cat $p/comm 2>/dev/null)"
done | sort -rn | head -20
# 保护 MySQL:让它几乎不会被选中
echo -300 > /proc/$(pidof mysqld)/oom_score_adj更好的做法是用 systemd 的 OOMScoreAdjust,重启后依然生效:
systemctl edit mysql
# 加入:
# [Service]
# OOMScoreAdjust=-300注意:负值是要谨慎用的。把 MySQL 保护起来,意味着内存不足时被杀的就变成了别的进程;如果系统里所有进程都被保护了,内核最后会杀掉 sshd 或者干脆 panic。保护只应该给「重启代价最大、且内存可控」的那一两个进程。
算一笔账:物理内存到底被谁占了
排查到这一步,手里有进程列表还不够,得有账本。我习惯按下面这个次序做:
# 1. 总量与构成
free -m
cat /proc/meminfo | grep -E 'MemTotal|MemFree|MemAvailable|Buffers|Cached|Slab|PageTables|KernelStack'
# 2. 进程按 RSS 排序(PSS 更能反映共享内存真实归属)
ps -eo pid,user,rss,pmem,comm --sort=-rss | head -20
# 3. 更准的:PSS(共享库/共享内存按比例摊到各进程)
cat /proc/*/smaps_rollup 2>/dev/null | awk '/^Pss:/{s+=$2} END{print "total PSS MB:", s/1024}'关键判断在 MemAvailable 和 MemFree 的差别上。很多人看到 free 很小就以为内存不够,其实 Cached 那部分是可以随时回收的。真正该看的指标是 MemAvailable,它是内核估算的「在不触发 swap 的前提下还能给新进程用的内存」。如果 MemAvailable 长期低于总内存的 10%,那就真该动手了;如果 MemAvailable 还有 30% 而 free 很小,那只是缓存吃饱了,一切正常。
各类内存的大致归属顺序,排查时按这个顺序查最省时间:
第一是进程 RSS,占了 70% 以上是常态。第二是 PageTables,多进程程序(比如 PHP-FPM 开 200 个子进程)的页表开销可能到几百兆,这个很容易被忽略。第三是 Slab,尤其是 slab_unreclaimable,dentry 和 inode 缓存在遍历大量小文件的站点上会疯长。第四是 kernel stack,每个线程一份,线程数爆炸时才会显著。
# Slab 明细,看是谁在吃
slabtop -o | head -20
# dentry / inode 是可回收的,但如果 reclaimable 很大而系统仍然 OOM,
# 说明回收跟不上分配速度,通常是内存严重不足虚拟内存与 overcommit:申请了不等于真给了
有一个很反直觉的现象:ps 里所有进程的 VSZ 加起来可能有 8G,而机器只有 4G 内存,系统却一切正常。原因是 Linux 默认允许 overcommit——进程 malloc 的时候内核先记账但不真给页面,等真正写到那个地址才分配物理内存。这叫「惰性分配」。
cat /proc/sys/vm/overcommit_memory
# 0 = 启发式(默认),1 = 永远允许,2 = 严格按比例
cat /proc/sys/vm/overcommit_ratio
# 仅在 mode=2 时生效三个值对应的行为:0 是内核凭经验拒绝明显过分的申请;1 是无脑放行,然后等 OOM killer 收场(Redis 官方文档明确建议设成 1,因为 fork 做 RDB 快照需要大量虚拟内存,而 mode 0 会误判拒绝);2 是严格模式,按 CommitLimit = swap + 物理内存 × overcommit_ratio% 卡死。
这里有个坑值得单独说:把 overcommit_memory 设成 2 很容易把站点搞挂。因为 PHP-FPM 每 fork 一个 worker 都有一份虚拟地址预留,几十个 worker 加起来 commit 量很容易超过 CommitLimit,结果是 fork 直接失败、PHP-FPM 报 unable to fork,而系统内存其实还有一大半空着。我见过不止一次有人为了「防止 OOM」而设成 2,结果换来了更难查的 fork 失败。真要控内存,用 cgroup 或者 systemd 的 MemoryMax,别动 overcommit。
容器与 cgroup v2:被杀的其实是整个组
如果站点跑在 Docker 或 systemd 的 cgroup 里,OOM 会先在组内发生,可能根本不进全局内核日志。判据是:
# cgroup v2(Debian 11+/Ubuntu 21.10+ 默认)
cat /sys/fs/cgroup/system.slice/php8.1-fpm.service/memory.events
# 关注 oom_kill 计数
# Docker 容器
docker inspect --format '{{.State.OOMKilled}}'
cat /sys/fs/cgroup/system.slice/docker-.scope/memory.max
cat /sys/fs/cgroup/system.slice/docker-.scope/memory.peak
# 宿主机的 memcg OOM 记录
dmesg -T | grep -i 'Memory cgroup out of memory' memory.events 里如果有 oom 3 和 oom_kill 3,就说明这个组被杀了三次。注意 memory.max 和 memory.high 的区别:max 是硬上限,超了就杀;high 是软上限,超了会被限速并强制回收,通常只会拖慢而不会杀。给 PHP-FPM 配 MemoryHigh=1G + MemoryMax=1200M 是比直接设 Max 更友好的组合——它会先受节制,实在不行才被杀。
还有一个大坑:cgroup 里的 page cache 也算在配额里。容器里跑 MySQL,读文件产生的 cache 会让 memory.current 一直贴近 max,看着像是「内存满了」,但其实可以回收。可一旦回收跑不过分配速度,就会被判 OOM。所以在容器里跑数据库要显式留出余量,别把 max 设得跟物理内存一样。
事后定位:没有日志怎么知道是谁涨上来的
OOM kill 不留崩溃日志,但能留下三个间接证据。
证据一:cgroup 的 memory.peak / memory.max_usage。如果开了 cgroup v2,memory.peak 记录了历史最高点,能确认「是不是真的撞到了上限」。
证据二:进程的启动时间。被杀的进程重启后,systemctl show -p ActiveEnterTimestamp php8.1-fpm 的时间点,往往和 OOM 记录精确对齐。反过来,如果发现某进程一天重启了五六次而日志干净,几乎可以断定是被杀的。
证据三:vmstat 的历史数据。sysstat 每 10 分钟采一次,sar -r -f /var/log/sysstat/sa15 能画出内存曲线;sar -B 看 pgscank/pgscand(直接回收扫描量),OOM 之前这两个值会飙高。sar -W 看 pswpin/pswpout,是 swap 抖动的证据。
sar -r -f /var/log/sysstat/sa$(date +%d) | tail -30
sar -B -f /var/log/sysstat/sa$(date +%d) | tail -30
# 若 sysstat 没装:apt install sysstat && systemctl enable --now sysstat我更推荐一个土办法:用 cron 每分钟把 free -m 和 RSS Top 5 追加到一个文件里,保留 3 天。它占的空间极小,但在真出事的那天,这个文件比任何监控面板都好用。
# /etc/cron.d/memwatch
* * * * * root { date '+%F %T'; free -m | sed -n '2p'; ps -eo rss,comm --sort=-rss | head -6; echo; } >> /var/log/memwatch.log 2>&1
# 配合 logrotate 每天切一次、保留 3 份治本:把内存预算定下来
清理缓存、重启进程都是治标。真正要做的是一次静态分配,把「总内存 × 安全系数」拆给各角色,让它们加起来不超过物理内存的 80%。以一台 4G 的小站机器为例:
# PHP-FPM 池(这是最容易失控的部分)
pm = static / dynamic
pm.max_children = 20
# 峰值时单进程 RSS 用 ps 观察得到,假设 90M
# 20 × 90M = 1800M ← 这一项就决定了预算的上限
# MySQL
innodb_buffer_pool_size = 512M
# 经验值:小站用总内存的 25%~40%,不要超过 50%
# Nginx
worker_processes = 2
# 每个 worker 的连接缓冲:worker_connections × 2 × client_body_buffer
# 通常 50M~100M 足够
# 预留
# 系统 + sshd + cron + 日志:300M
# 剩余:4G - 1800 - 512 - 300 ≈ 1.3G ← 安全垫,也该保持这么多算完这一笔,往往就发现问题所在了:不是内存不够,是 max_children 定得太大。默认配置里 max_children 经常被随手写成 50,而每个 PHP 请求峰值占 80~150M,50 个就是 5G,一台 4G 机器必然 OOM。正确的推法是:先量单进程峰值 RSS(ps -eo rss,comm | grep php-fpm | sort -rn | head -1),再用「可用内存 ÷ 单进程峰值 × 0.7」倒推 max_children。
另外要区分「常驻」和「瞬时」。pm = dynamic 下 pm.max_spare_servers 决定了平时挂多少空闲进程,pm.max_requests 决定了子进程跑多少个请求后自杀重建(设为 500~1000 可以防内存泄漏累积,这是 PHP 老代码的救命参数)。如果代码里有明显的内存泄漏(比如常驻的框架缓存不释放),设 max_requests 是必要的止损:内存涨到阈值前就换一个新进程,比等 OOM 强。
该不该加 swap:一个被反复争论的问题
有一种流行说法是「服务器不要开 swap,会变慢」。这句话只对了一半。
swap 确实慢(机械盘上差几百倍,SSD 上也差两个数量级),但它有一个不可替代的作用:把「突然的尖峰」和「真的不够」区分开。没有 swap 时,一个只需要 200M 但瞬间申请 1G 的进程会直接触发 OOM;有 1G swap 时,它可能把冷页面换出去、平稳度过尖峰,也没被杀。所以我的做法是给小站配总内存的 25%~50% 的 swap,同时把 vm.swappiness 调到 10:平时几乎不用,只在紧急时当缓冲垫。
# 建一个 1G 的 swap 文件(云主机常常没分区)
fallocate -l 1G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo '/swapfile none swap sw 0 0' >> /etc/fstab
sysctl -w vm.swappiness=10
echo 'vm.swappiness=10' >> /etc/sysctl.d/99-swap.conf注意:swap 只是缓冲,不是容量。如果 sar -W 显示 pswpin/pswpout 长期非零,说明内存是真的长期不够,换内存或减少常驻进程才是答案。而且 swap 放在被大量写入挤占的盘上时,性能会更糟;如果 VPS 的盘是小容量 SSD 且已接近写满,加 swap 前先确认还留有余量,否则会把磁盘IO 也拖垮。
一份可以直接抄的检查单
我把这套流程压缩成七步,按顺序做,不跳步:
1. 确认是 OOM。看 dmesg -T | grep -i 'killed process',看 cgroup 的 memory.events,看进程的重启时间是否与告警吻合。三者对上才算确认。
2. 读那条消息的三个字段。进程名、anon-rss(真实占用)、UID(是哪个用户跑的)。
3. 看全局还是组内。全局 OOM 有 Mem-Info 的上百行;组内 OOM 只有寥寥几行、且提到 cgroup。这决定下一步查内核还是查配额。
4. 算账。free -m 看 MemAvailable,ps --sort=-rss 看谁最大,slabtop 看内核对象,PageTables 看多进程开销。
5. 找增长源。靠 sar -r 曲线或自建的每分钟快照。如果没有任何历史数据,先补上再谈定位。
6. 定预算。把 max_children、buffer_pool、worker 数写成一组数字,加起来不超过 80%,剩下的当余量。这组数字写进运维文档。
7. 上护栏。给关键进程配 OOMScoreAdjust(负值但别太狠),给 PHP-FPM 配 pm.max_requests,给容器配 MemoryHigh + MemoryMax 双档,把 swap 加上但 swappiness 调低。
这套东西做完之后,同样的流量尖峰再来一次,结果会从「凌晨三点被电话叫醒」变成「早上看日志发现有个进程昨天夜里重启过一次」。运维的价值不在救火,在于让火根本烧不起来。
小结
OOM kill 之所以难查,是因为它把信息写在了应用看不到的地方。记住三件事就够了:内核日志里有完整证据(dmesg/journalctl -k);判据是 anon-rss 而不是 total-vm;治本靠一份把 max_children 算进去的内存预算,而不是靠杀进程。再把 swap 和 swappiness 当缓冲垫而不是容量,把 cgroup 的 dual-limit(high/max)配好,一个人维护的小站也完全能扛住突发流量。