CPU 打到 100%,重启就好了?下次还会来
CPU 告警这事有个很坏的习惯:重启。
重启确实有效,五分钟后 CPU 从 98% 掉到 12%,告警消了,工单关了。然后第二天同一时间,又来了。
因为重启只是终止了正在烧 CPU 的那个循环,一行代码都没改。
要真正解决,得先回答一个问题:是谁在烧?
答案只有三类,而且三类的处理方式完全相反。

一、先分类:GC、JIT、还是业务
top 看到进程 100%,下一步必然是 top -Hp <pid> 看线程。这时候屏幕上会出现一堆线程名,看名字就能初步归类:
PID USER PR NI VIRT RES %CPU COMMAND
3821 app 20 0 12.4g 3.1g 92.3 java
3846 app 20 0 12.4g 3.1g 91.8 GC Thread#3
3872 app 20 0 12.4g 3.1g 46.2 C2 CompilerThre
3901 app 20 0 12.4g 3.1g 88.1 http-nio-8080-1
3902 app 20 0 12.4g 3.1g 84.4 http-nio-8080-2
GC Thread 高 → 不是代码慢,是对象造得太快或者堆太小。去查 GC 日志,看是不是 Full GC 频繁,或者年轻代太小导致对象过早晋升。
C2 CompilerThread 高 → JIT 在疯狂编译。这个通常是结果不是原因:因为方法被反复调用,JIT 才去编译它。所以它高,说明热点方法在被打爆,转去查业务。
http-nio / dubbo / 自定义线程池前缀高 → 业务线程在烧 CPU。这才是要 jstack 的场景。
这一分类决定了后面所有的动作。 我见过有人在 GC 线程 90% 的情况下去 jstack 找业务线程,翻了半小时线程栈,什么都没找到——因为问题根本不在那儿。
看 GC 是否真的在忙,一条命令:
jstat -gcutil <pid> 1000 20
# 关注 FGC 列(Full GC 次数)和 FGCT(总耗时)
# 20 秒内 FGC 涨了 8 次,FGCT 涨了 12 秒 → 60% 的时间在 Full GC
如果 FGCT 的增长速度接近总耗时的 60% 以上,CPU 就是被 GC 吃掉的。这时候去看堆,别在线程栈上浪费时间。
二、把线程钉到代码行:三步
确认是业务线程之后,标准三板斧。
第一步,找到最烧 CPU 的线程号。
top -Hp 3821
输出里的 PID 是线程 ID(十进制的 tid),记下最高的那个,比如 3901。
第二步,转成十六进制。
printf '%x\n' 3901
# f3d
为什么要转?因为 jstack 输出里的 nid 是十六进制。这一步忘了做,后面搜不到,很多人卡在这。
第三步,抓线程栈,搜 nid。
jstack 3821 > /tmp/stack.txt
grep -A 30 "nid=0xf3d" /tmp/stack.txt
-A 30 是关键,只搜到那一行没用,要看它下面 30 行。
三、栈顶三行,读法比命令重要
拿到栈之后,看栈顶(最上面那几行,也就是当前正在执行的方法)。
情况 A:栈顶在业务包名下,而且反复出现同一个方法。
"http-nio-8080-exec-1" #41 daemon prio=5 os_prio=0 tid=0x... nid=0xf3d runnable
at com.example.order.OrderService.calcPrice(OrderService.java:187)
at com.example.order.OrderController.submit(OrderController.java:64)
这就是死循环或者大计算。看行号,直接定位。
情况 B:栈顶在 java.util.regex.Pattern$...。
正则回溯。这是 CPU 打满最常见的原因之一,而且极其隐蔽——因为代码看起来完全正常。
情况 C:栈顶在 java.util.HashMap.resize / transfer。
HashMap 并发扩容。JDK 8 之后不会死循环了(改成了尾插),但多线程同时 put 会导致数据覆盖和 CPU 飙升。用 ConcurrentHashMap。
情况 D:栈顶在 java.net.SocketInputStream.socketRead0。
这是在等 IO,不是在烧 CPU。如果这个线程出现在你 top -Hp 的榜单上,说明它恰好采样到了,不代表它耗 CPU。这一类要排除掉。
这一条很重要:jstack 只能看到"此刻",而死循环是持续的、IO 等待是间歇的。 所以采样要采多次,同一个方法在 3 次采样里出现 3 次,才能确认。
四、正则回溯:最冤的一种 CPU 打满
单独拎出来说,因为它太典型了。
// 看起来毫无问题
boolean ok = input.matches("^([a-z0-9]+\\.)*[a-z0-9]+@[a-z0-9]+\\.[a-z]{2,}$");
如果 input 是用户传上来的一个 200 字符的字符串,恰好包含大量 a. 组合,这条正则的匹配次数会变成指数级。
一个 30 字符的恶意输入,能让一个线程卡住几十秒,CPU 满格。
为什么会这样? 因为 (x+\.)* 这种"嵌套量词",在匹配失败时会尝试所有可能的组合。a.a.a.a.a.a... 后面接一个不匹配的字符,回溯次数是 2 的 n 次方。
怎么防:
- 别用
matches()做长文本校验,改成Pattern.compile()预编译 +matcher().find(),至少省掉重复编译。 - 输入长度先截断,超过 100 字符的手机号/邮箱直接拒。
- 复杂校验用
StringUtils.isEmail这类实现,或者用[a-z0-9]+(\\.[a-z0-9]+)*这种没有嵌套量词的写法。
怎么确认是它? jstack 里看到栈顶是 java.util.regex.Pattern$Curly.match 或 Pattern$GroupHead.match,并且这个线程一直在 RUNNABLE。
五、几个真实案例,都很有代表性
案例一:日志打太多。
一个接口里循环处理 5000 条数据,每条打一行 log.info。日志框架是同步的,写磁盘占满了 IO 和 CPU。
特征:CPU 高,但 jstack 里业务方法栈不怎么深,栈顶常常在 FileOutputStream.writeBytes。
解法:循环内日志降级到 debug,或者用异步 appender。
案例二:String.split 用在超大字符串上。
一次解析 20MB 的 CSV,content.split("\n"),瞬间创建 20 万个 String 对象。CPU 打满(字符串拷贝)+ 堆飙升。
特征:CPU 和内存同时告警。
解法:流式读取,BufferedReader.readLine() 一行一行处理。
案例三:加密 / 压缩 / 序列化占了大头。
明明是个查询接口,CPU 却很高。最后发现返回的对象有 300 个字段,每次序列化成 JSON 花了 40ms,QPS 200 的时候就是 8 核满载。
特征:jstack 栈顶在 com.fasterxml.jackson 或者 ObjectOutputStream。
解法:字段裁剪(返回 VO 而不是 DO)、开缓存、或者换更快的序列化。
案例四:定时任务和业务抢 CPU。
每天凌晨 2 点 CPU 飙到 100%,白天正常。查下来是一个全量同步任务,单线程跑 200 万条数据。
特征:有规律的时间点。看到这个特征,先去看定时任务列表,别在线程栈里瞎找。
六、反直觉:CPU 不高,但接口很慢
这类问题经常被归到"CPU 问题"里一起讨论,但根因完全不同。
CPU 只有 20%,RT 从 100ms 涨到 3s。
这时候去看线程状态分布,大概率是这样:
jstack <pid> | grep "java.lang.Thread.State" | sort | uniq -c
# 412 WAITING (on object monitor)
# 18 TIMED_WAITING (parking)
# 31 RUNNABLE
400 多个线程在 WAITING,说明它们都卡在锁上。
这不是 CPU 问题,是锁竞争,或者是下游 IO 阻塞导致的线程池打满。
典型场景:数据库连接池只有 10 个连接,200 个请求线程全在 getConnection() 上排队。CPU 当然不高——它们都在等。
另一个场景:调下游 HTTP 接口,超时设了 30 秒。下游一慢,线程全挂在那儿,CPU 闲着,但用户全超时。
判断方法就一句:RUNNABLE 的线程数远小于总线程数,问题在等待;RUNNABLE 数量接近线程池上限且都在业务方法里,才是真在算。
这两个方向的优化完全相反:一个要加线程/加连接/查下游,一个要优化算法/减计算。搞混了就是白干。
七、一条命令顶十次重启
上面这些命令都对,但在生产上一条条敲太慢,尤其是还在告警的时候。
arthas 的 thread 命令能一次看完:
# 看最忙的 3 个线程,直接给出栈
thread -n 3
# 看所有线程的状态分布
thread --state RUNNABLE
# 持续采样,找 CPU 最高的
thread -n 3 -i 2000
thread -n 3 的输出直接就是"线程名 + 占用率 + 完整栈",省掉了 top -Hp → printf → jstack → grep 四步。
如果要看方法级的热点(哪个方法占了多少 CPU),用 profiler:
profiler start --event cpu
# 等 30 秒
profiler stop --format html
会生成一个火焰图。火焰图的读法:横轴是占比(越宽越耗 CPU),纵轴是调用栈(越深调用层级越深)。找最宽的那一摞,从下往上读。
几个要注意的:
thread -n 3会短暂 STW(默认 500ms 左右采样),生产上用-i控制间隔,别在高并发时刻乱敲。- 别用
kill -3 <pid>,它会触发一次完整的线程转储并把结果打到 stdout,如果 stdout 是同步写文件,这一下可能让服务卡几秒。 - dump 出来的 stack 文件注意脱敏,里面有 SQL 和参数。
八、回到那个重启的习惯
最后说回开头。
重启能解决 CPU 100%,是因为它终止了那个正在跑的循环。但它没有改变任何一行代码。
下次还会来的原因很朴素:同一个输入还会再来一次。
所以看到 CPU 告警,正确的顺序是:
- 别急着重启,先
top -Hp抓一次线程快照(十秒钟的事,服务还没死) jstack存一份,jstat -gcutil存一份- 再重启
有了这两份文件,事后能查出根因。没有,就只剩一个"重启后恢复了"的工单,下周再来一遍。
故障现场只存在一次。 重启之后,那些线程栈、GC 数据、堆状态,全都没了。
CPU 打满这类问题,本质上考的是"你能不能在没有监控面板的情况下,靠几条命令把范围从一台机器缩到一个方法"。
这个能力不是背命令背出来的,是把 JVM 的线程模型、GC 机制、锁的实现都过一遍之后自然长出来的——你知道 WAITING 意味着什么,才知道该往哪查。
这套东西我是跟着一套 Java 后端课程把源码逐个断点过的,从 Bean 生命周期、MyBatis 缓存、Spring 事务,到 AQS、ConcurrentHashMap、Nacos 注册,每一节都配了调试记录。

想要这套笔记 + 源码调试记录的,扫码加我,备注「Java」👇

不用转发、不用关注,加上直接发你。
1310



被折叠的 条评论
为什么被折叠?



