一次线上 CPU 飙到 100% 的排查实录:从 jstack 到根因,只花了 20 分钟
一次线上 CPU 飙到 100% 的排查实录:从 jstack 到根因,只花了 20 分钟
线上告警响了:某服务 CPU 使用率持续 100%,接口超时。重启能暂时压下去,但几小时后必然复发。
这篇记录完整的排查过程——不是“我用了什么命令”,而是每一步为什么这么走、看到了什么、怎么排除的。最终根因是一段看着完全正常的代码。希望你看完能少走一遍同样的弯路。
先说现象
- 单实例 CPU 打满,但内存、GC、磁盘 IO 都正常;
- 接口不是全挂,是部分请求变慢,偶发超时;
- 重启后恢复,几小时后复发,有周期性;
- 日志里没有异常堆栈,没有 OOM,没有 Full GC 频繁的迹象。
这几个特征基本排除了内存泄漏、GC 问题和大范围死锁——如果是这些,内存曲线和 GC 日志会有明显异常。CPU 打满 + 内存正常 + 无异常日志,最典型的嫌疑是某个线程在死循环或高频自旋。
第一步:先抓现场,别急着重启
重启会销毁现场,这是排查 CPU 问题的大忌。正确顺序是:先保留现场,再重启。
登录机器,先确认是不是 Java 进程占的 CPU:
top -Hp <pid>
-H 是关键,它把进程内的所有线程展开显示。这一步直接告诉你:是某一个线程吃满了一个核,还是几十个线程在平分 CPU。
我的现场是:一个线程占了 98% 以上的单核 CPU,其他线程都很闲。这就锁定了方向——单个线程陷入死循环或长时间计算,不是全局性问题。
第二步:把线程 ID 转成十六进制
top -Hp 输出的线程 ID 是十进制,而 jstack 里的 nid 是十六进制。转换一下:
printf "%x\n" <线程ID>
比如线程 ID 是 12345,转出来是 3039。接下来在 jstack 输出里搜这个 nid 就能定位到具体线程。
第三步:jstack 抓栈,连抓三次
jstack <pid> > stack1.txt
sleep 3
jstack <pid> > stack2.txt
sleep 3
jstack <pid> > stack3.txt
为什么抓三次?因为单次快照可能正好停在无害的瞬间。如果一个线程连续三次都停在同一段业务代码的同一个方法里,那它大概率就是卡在那里转圈的那个。
在 stack1.txt 里搜 nid=0x3039,找到类似这样的栈:
"pool-3-thread-7" #47 prio=5 os_prio=0 tid=0x00007f... nid=0x3039 runnable [0x00007f...]
java.lang.Thread.State: RUNNABLE
at java.util.HashMap.getNode(HashMap.java:569)
at java.util.HashMap.get(HashMap.java:545)
at com.example.service.OrderCache.lookup(OrderCache.java:42)
at com.example.service.OrderService.query(OrderService.java:88)
...
三次快照,这个线程都停在 HashMap.getNode。RUNNABLE 状态、停在 HashMap 的 get 里——这几乎可以断定:有线程正在一个 HashMap 上做高频查找,而且这个 Map 出了问题。
第四步:读代码,找出“看着正常”的根因
顺着栈定位到 OrderCache.java:42,代码大致长这样:
public class OrderCache {
private static final Map<String, Order> CACHE = new HashMap<>();
public static Order lookup(String orderId) {
return CACHE.get(orderId); // 第 42 行
}
public static void put(String orderId, Order order) {
CACHE.put(orderId, order);
}
}
一个静态 HashMap 当本地缓存用,没有加锁、没有容量上限。代码本身确实简单到“看着没问题”,但问题恰恰出在这。
根因一:HashMap 不是线程安全的。 多个线程同时 put 时,HashMap 可能进入一种环形链表状态(JDK 7 扩容时头插法尤其容易出现;JDK 8 改成了尾插法,环形链表概率降低,但并发读写仍会导致数据错乱、节点丢失)。一旦某个 bucket 上的链表成环,get 操作在遍历链表时就永远走不出来——这就是那个 98% CPU 线程的来源:它在环形链表里无限循环。
根因二:无界缓存 + 周期性与写入高峰重合。 为什么是“几小时后复发”?因为缓存持续增长,直到某个扩容点 + 并发写入高峰叠加,成环被触发。
这两条合在一起,解释了我看到的所有现象:CPU 被打满(死循环线程)、内存正常(数据量还没大到 OOM)、无异常日志(死循环不抛异常)、重启恢复(链表重建)、周期性复发(缓存再次增长到危险点)。
第五步:修复
最小改动、根治问题的写法:
private static final Map<String, Order> CACHE =
Collections.synchronizedMap(new LinkedHashMap<String, Order>(16, 0.75f, true) {
@Override
protected boolean removeEldestEntry(Map.Entry<String, Order> eldest) {
return size() > 10000; // 有界,超限淘汰最久未访问的
}
});
如果读多写少、追求更高并发,用 ConcurrentHashMap 是更好的选择:
private static final ConcurrentHashMap<String, Order> CACHE = new ConcurrentHashMap<>();
但要记住:ConcurrentHashMap 只保证并发安全,不解决“无界增长”问题。容量控制仍需要自己加(比如用 Caffeine 这类带淘汰策略的缓存库)。
复盘:几个值得记住的点
1. 排查 CPU 问题,第一原则是别重启。 先 top -Hp 抓线程,再 jstack 抓栈,最后才考虑重启止损。现场只有一次。
2. 单次 jstack 不可靠,连抓三次对比。 线程短暂经过某个方法 vs 一直卡在某个方法,只有多次快照能区分。
3. RUNNABLE + 停在集合类内部循环,优先怀疑“数据结构被并发破坏”。 HashMap 成环、链表成环、死循环,这类问题的栈特征非常明显:线程状态是 RUNNABLE,栈顶停在 HashMap.getNode / HashMap.get 这类方法。
4. 所有静态 HashMap 当缓存的代码,都值得审一遍。 尤其是那种“本地缓存、图个快”的临时方案,往往既没并发保护,也没容量上限——埋下的雷会在某个写入高峰准时引爆。
5. 日志干净不代表没问题。 死循环、自旋、并发破坏数据结构,这些都不会在日志里留痕迹。排查这类问题,线程栈比日志有用得多。
附:常用排查命令速查
# 1. 找出占 CPU 的线程(进程内展开)
top -Hp <pid>
# 2. 十进制线程 ID 转十六进制
printf "%x\n" <线程ID>
# 3. 抓线程栈(连抓三次,间隔 3 秒)
jstack <pid> > stack1.txt && sleep 3 && jstack <pid> > stack2.txt && sleep 3 && jstack <pid> > stack3.txt
# 4. 在栈里按 nid 定位线程
grep -A 30 "nid=0x3039" stack1.txt
# 5. 统计各线程状态分布(快速看有没有大量 BLOCKED / WAITING)
grep "java.lang.Thread.State" stack1.txt | sort | uniq -c | sort -rn
一句话收尾:CPU 飙高不可怕,可怕的是重启了、现场没了、问题还在。 先抓栈、再定位、最后修复——这套顺序能帮你把绝大多数“偶发、难复现”的 CPU 问题钉死在具体的那一行代码上。
- 点赞
- 收藏
- 关注作者
评论(0)