Java线上CPU飙高与死锁排查实战:从jstack到Arthas全流程
1. 先从一次真实的线上事故说起:CPU 400% 意味着什么
做 Java 开发的朋友,几乎都会遇到一次这样的半夜惊醒:业务群里有人说系统卡死了,请求大面积超时。你打开监控面板,看到一台应用服务器的 CPU 使用率已经冲到 400% 甚至更高,load average 飙到几十。再一看,Java 进程还在,但 JVM 似乎已经“僵”在那里,线程池里的任务全堵着,GC 日志里 Full GC 的频率高到吓人。
这种时刻,最忌讳的就是乱猜。有人说是代码有死循环,有人说是 GC 出问题了,还有人怀疑是机器被入侵挖矿了。在我刚带团队那几年,每次遇到这种问题,第一反应也是先重启大法。但重启只能缓解,不能根治。你今天重启了,明天它还会再炸。真正要做的是拿到现场证据,把根因挖出来。这篇文章就是要把我自己在多次 CPU 飙高和死锁排查中沉淀下来的那套动作,从头到尾拆开讲清楚。适合谁看?正在背八股文找工作、想积累线上问题排查经验的 Java 开发者,以及日常工作里会碰到线上事故、需要自己定位问题的后端工程师。这里涉及的技术点不复杂,但每一步都要做到位,缺一环可能就要多折腾好几个小时。
先说一个基本常识:当一台 Linux 服务器上 CPU 使用率高企时,top 命令是最直接的入口。但 top 只能看到进程维度,也就是哪个 Java 进程在烧 CPU。要往深挖,必须配合 top -Hp、jstack、jstat、jmap 这一整套工具链。本文的核心就是:如何用这套工具链,从“CPU 飙高”这个表象,一路追到到底是哪一行代码在搞事情,并且把 Java 死锁这类并发问题的排查逻辑一并说透。
2. 从 top 到 jstack:CPU 飙高排查的标准动作
2.1 第一步永远不是看代码,而是看现场
CPU 飙高这类问题,最怕的是你等到了第二天再处理。很多现场信息是转瞬即逝的。所以在处理线上事故时,我的习惯是先开一个临时目录,把各种现场信息先 dump 下来,再做分析。别一上来就翻代码、问同事最近改了什么,那些是后面的事,先把证据固定住。
第一步,运行 top,确认哪个进程在吃 CPU:
-c 参数会展示进程的命令行,这样可以快速区分是 Java 进程、GC 进程、Kafka 进程,还是别的什么。正常情况下,你会看到类似这样的输出:
%CPU 380.0 意味着这个 Java 进程占用了将近 4 个 CPU 内核。TIME+ 是累计 CPU 时间,如果这个值已经很大,说明问题不是刚刚发生的,而是持续一段时间了。这时候你要做的,就是把进程 PID 记下来,比如这里是 23456。
紧接着,除非你确定进程随时可能挂掉必须立刻重启,否则千万不要直接 kill。因为下一步的线程级采样,需要这个进程还活着。如果实在压力太大需要止损,那就先用 jstack -l 把线程栈 dump 下来再重启,哪怕多花几秒钟,换来的可是根因线索。
2.2 定位到具体线程:top -Hp 是承上启下的关键一步
进程确定之后,下一步必须找到进程内部的线程维度。这一步用 top -Hp:
输出会变成线程级的,多了一个 TID(线程 ID)列:
这里有两个线程的 CPU 使用率都在 99% 左右,说明至少有两个线程在并行地疯狂消耗 CPU。线程 ID 一般是个十进制数,但 jstack 输出里的线程 ID 是十六进制的,所以你需要做一个转换。比如 23458 转换成十六进制是 0x5ba2。
转换我一般直接用 printf:
也可以直接用 python:
这一步的重点是:拿到线程 ID 的十六进制值,然后在 jstack dump 下来的栈里,通过这个值去匹配对应的线程。如果你的 jstack 输出已经滚动过去了,或者是分批 dump 的,那么匹配的时候要找 nid=0x5ba2 这样的字段。
2.3 线程栈的采样技巧:一次 dump 不够,至少三次
很多初学者栽在这里:好不容易把 jstack 的栈 dump 下来了,但发现里面全是 WAITING、TIMED_WAITING 状态的线程,根本看不出谁在烧 CPU。原因很简单——如果只 dump 一次,高 CPU 线程正好处于某个短暂的停留点,栈里的内容可能看不出热点。正确做法是:间隔几秒连续 dump 多次,而且最好同时记录当时的 CPU 占用。
多份栈对比,才能看出线程栈是稳定地卡在某个位置,还是在多个位置之间快速切换。如果三次都指向同一个方法,那基本就是“死循环”或“自旋等待”之类的问题;如果三次栈在变化,那可能是某个方法耗时特别长,或者是在做大量计算。
同时,配合 jstat 看一下 GC 情况:
S0、S1、E、O 分别是幸存区、伊甸园区、老年代的使用率,YGC、FGCT 是 GC 次数和时间。如果 O 区长期爆满,FGCT 高得离谱,那 CPU 飙高的原因十有八九是 GC 频繁。这时候要解决的是内存分配和对象回收问题,而不是死循环。这份数据也是排查中必不可少的证据。
3. 线程栈不会说谎:一次 GC 抖动和一次死循环的定位实录
3.1 案例一:CPU 高但线程栈里全是图片压缩逻辑
有一回排查一个图片上传服务的 CPU 飙高问题。top -Hp 看到两个线程 CPU 接近 100%,十六进制 TID 分别是 0x3a21 和 0x3a22。连抽三份 jstack,这两条线程的栈高度一致,都卡在:
三次栈完全一致,这就不是巧合了。这段日志告诉我们:线程池中的线程正在执行 JPEG 编码,而且是本地方法 JPEGImageWriter.encodeImage。图片压缩服务烧 CPU,本身就有点敏感。我马上看了一眼堆内存,果然老年代的使用率很高,Full GC 很频繁。因为每张图片压缩完都会产生一个大 byte[],如果并发上来,这些大对象会直接进老年代,然后老年代不断被填满,触发 Full GC。
解决思路就比较清晰了:一方面压缩完的 byte[] 尽可能复用,不要把整个图片字节数组长期滞留内存;另一方面给图片压缩线程池设置合理的队列长度和拒绝策略。后来我们把压缩逻辑改成流式处理,不落全量 byte[],GC 压力小了很多,CPU 自然也掉下来了。
这个案例的教训是:CPU 飙高未必是死循环,也可能是 GC 抖动。而判断是 GC 还是死循环,不能只靠猜,要 jstack 和 jstat 一起看。这里线程栈里是 RUNNABLE 状态,而且本地方法栈卡在图片编码上,说明这些线程确实在做计算密集的工作,不是靠 GC 线程在消耗 CPU。
3.2 案例二:一段看似无害的字符串拼接,把 CPU 吃满了
再讲一个更“隐蔽”的情形。某个内部数据处理服务,每隔一段时间 CPU 就会拉满,而且没有任何异常日志。jstack 看的时候,高 CPU 线程停在:
乍一看,StringBuilder.append 怎么可能会把 CPU 吃满?实际上,这里的问题不是 append 本身,而是它所在的循环。看源码后发现,formatData 里有个 while (iterator.hasNext()) 循环,对几十万条数据做格式化拼接。每次循环都 new StringBuilder(),并且拼接的字段里有一个频繁触发的 String.format,开销不小;再加上循环体里还有正则表达式匹配,正则引擎在某些输入下会进入灾难性回溯,CPU 占用就爆炸了。
这种问题光看线程栈有时候不太够,因为线程栈只显示出栈顶的方法。我的习惯是看 jstack 里那一整条栈,多抽几次,看栈里的帧是否都在同一段代码里反复出现。如果栈顶变了但栈底不变,基本可以确定是在某个循环里反复执行同一批逻辑。然后把源码拉出来,重点看循环体内有没有明显的计算密集操作,比如正则、序列化、加解密、大量字符串操作等。
顺带说一句,正则灾难性回溯是个非常经典的 CPU 杀手。它的原理是正则引擎在某些模式上会做大量回溯尝试,导致时间复杂度从 O(n) 恶化到 O(2^n)。如果你发现线程栈里出现 java.util.regex.Matcher 相关的方法,优先级非常高,一定要尽快把正则表达式换掉或者做成预编译模式,同时构造一只能够覆盖最长可能输入的超时机制。
3.3 用 Arthas 做动态排查:线上无源码时的救命工具
线上环境经常没有源码,或者不方便重启,这时候我强烈推荐用 Arthas。它是一个 Java 诊断工具,可以直接 attach 到目标 JVM 上,不需要改代码、不需要重启。在 CPU 飙高场景下,Arthas 有一个命令非常有用:thread -n 3,它会直接列出 CPU 占用最高的前 3 个线程,并打印出它们的线程栈,省去手动转换 TID 的过程:
输出里会直接给出线程 ID、线程名、CPU 使用率以及堆栈信息,一眼就能看到热点。如果怀疑是某个方法的问题,还可以用 trace 命令追踪方法的调用耗时分布,看一下到底是哪一行代码耗时长:
trace 会显示出这个方法内部每个子调用的耗时,定位到瓶颈那一行。Arthas 还有一个很好用的能力是 watch,可以观测某个方法的入参和返回值,在排查“为什么数据特别多、导致拼接循环特别长”这点上,非常直接。当然,Arthas 是线上诊断工具,使用前需要确认安全合规,尽量不要在核心交易链路高峰期乱用,但在事故发生时它就是一把利器。
4. 死锁不是玄学:jstack 检测机制与经典案例拆解
4.1 jstack 凭什么能检测出死锁?
CPU 飙高和死锁看起来是两个方向的问题——一个烧 CPU,一个卡住不动。但在排查逻辑上,它们高度重叠:大部分并发问题的第一现场,都必须靠线程栈去还原。而当 Java 应用发生死锁时,线程通常不会烧 CPU,而是处于 BLOCKED 或 WAITING 状态,整个服务表现为请求超时、卡死、线程池耗尽。
这里有个容易被忽略的知识点:jstack 其实内置了死锁检测。当你执行 jstack -l 时,如果 JVM 发现了死锁,输出的末尾会有一段明确的提示:
这段信息直接告诉了你两件事:死锁涉及哪几个线程,以及每个线程在等哪把锁。仔细阅读后面打印的线程栈,就能还原出完整的“锁等待图”:线程 A 持有锁 X 想拿锁 Y,线程 B 持有锁 Y 想拿锁 X,两边谁也不让,死锁就形成了。
jstack 之所以能检测到,是因为 JVM 在 dump 线程栈时,会遍历所有 Java 监视器锁的持有关系,构建一张等待图,然后检查这张图里有没有环。有环,就是死锁。所以排查死锁的第一命令,依然是 jstack。
4.2 经典死锁案例:转账场景的动态顺序死锁
很多人看死锁的八股文案例都懂:两个线程,两把锁,互相等待。但真实线上死锁往往更隐蔽,最常见的一种是“动态顺序死锁”。我拿转账场景举个例子。
假设有两个账户对象,要执行转账操作。代码大概是这样:
表面上看,这个方法是安全的:锁住了转出账户和转入账户,避免了并发操作同一账户的问题。但只要两个线程同时执行方向相反的转账,死锁就来了。比如线程 1 执行 transfer(accountA, accountB),线程 2 执行 transfer(accountB, accountA)。线程 1 先拿到了 accountA 的锁,线程 2 先拿到了 accountB 的锁,然后线程 1 等着拿 accountB,线程 2 等着拿 accountA,互相掐死。
这个问题的本质是锁的顺序不一致,锁的获取顺序是由运行时参数决定的,而不是固定的代码顺序。解决思路很简单:给账户对象设计一个全局唯一的 ID,然后总是先锁 ID 小的那个账户,再加锁 ID 大的那个。这样无论传入顺序怎么变,两个线程抢锁的顺序都一样,死锁自然不可能发生。
这是一个很典型的“用排序消除动态顺序死锁”的案例。我特意把它写出来,是因为太多人在面试时能背出死锁的四个必要条件,但真到线上,面对这种动态顺序死锁,却不知道从哪里下手。
4.3 不太明显的死锁:协作对象间的回调死锁
除了 synchronized 锁,JUC 包里的显式锁也容易出现死锁,而且 jstack 对 ReentrantLock 的检测同样有效。不过有一种死锁更隐蔽:它不是因为两个线程抢两把锁,而是因为锁的持有者在等待一个协作对象的回调,而这个回调又反向需要同一把锁。
我遇到过这样一个场景。某个缓存组件内部用了读写锁,读操作持有读锁,然后回调一个监听器,监听器里又去调用了该缓存组件的写方法,试图获取写锁。在 Java 的 ReentrantReadWriteLock 里,读锁和写锁是互斥的,同一个线程可以在读锁内获取写锁吗?不行,因为内部有一个 firstReader 之类的机制,但写锁获取时会检查读锁是否被持有,而当前线程持有了读锁,就会发生“自己等自己”的锁升级死锁。这种死锁的表现不是两个线程互相掐,而是同一个线程内,读锁还没释放就去写,导致线程在等待队列里永远等下去。
排查这种问题,核心还是要看线程栈,但需要特别留意那些嵌套的回调关系。栈里可能显示线程持有某把锁,然后又等在一把读写锁上。只要看到“自己等自己”的逻辑,基本就能锁定问题。
5. 别让锁变成地雷:动态顺序死锁与数据库死锁的预防策略
5.1 从锁的粒度到锁的顺序:预防死锁的代码规范
如果说排查事故是“救火”,那么在写代码时防止死锁才是“防火”。我在团队里推行过几条非常实用的死锁预防规范,分享出来给大家参考:
- 能不用锁就不用锁:对于不可变对象、线程封闭的场景,直接避免锁的使用,自然就没有锁竞争和死锁问题。
- 缩小锁的范围:不要在锁内做耗时操作,比如网络请求、文件读写、大批量计算。尽量只锁真正需要保护的共享数据。锁范围越大,等待链越长,不仅容易死锁,性能也差。
- 锁顺序必须全局一致:如果一个系统里要保护多个资源,必须规定一种全局顺序,所有人都按这个顺序加锁,不允许“看心情”哪个先拿哪个后拿。
- 使用带超时的尝试锁:对于
ReentrantLock,强烈建议用tryLock(timeout)而不是无参lock()。一旦超过预设时间拿不到锁,就选择回滚重试,而不是无限期等待。这样即使真的发生死锁,也能自动暴露而不是永久卡死。 - 避免在锁内调用外部回调:这条对框架开发尤其重要。你锁住资源后,回调了一个外部注册的监听器,这个监听器里又会去获取别的锁,风险非常高。如果一定要回调,就先把必要的数据拷贝出来,释放锁之后再回调。
5.2 数据库死锁是另一层战场:行锁与索引缺一不可
很多 Java 死锁的讨论停留在 synchronized 和 JUC 层面,忽略了数据库死锁,但线上最常见的死锁其实是数据库层的。两个事务执行顺序交叉的 SQL,互相持有行锁等待对方的行锁,数据库会选择一个事务牺牲掉(回滚)来打破死锁,但业务层面会报死锁异常,影响用户体验。
数据库死锁的预防思路和 Java 层类似:一是要求所有事务按相同顺序访问表和数据行;二是尽可能减少事务持有锁的时间,长事务是死锁温床;三是确保 WHERE 条件能走索引,因为如果没走索引,数据库会锁全表或者更多行,大大增加锁冲突概率。排查数据库死锁,可以用 SHOW ENGINE INNODB STATUS 查看最近一次死锁信息,里面会打印出两个事务各自持有的锁和等待的锁,非常直观。
这里也提醒一句:如果应用层配置了连接池,某些情况下你会看到 jstack 里的线程卡在数据库驱动等待上,比如 WAITING 在 SocketInputStream 上,那么问题可能不是 Java 锁,而是连接池耗尽,底层是数据库慢查询或者死锁。不要只盯着 Java 层看,要结合慢 SQL 日志、连接池监控一起判断。
5.3 分布式锁的坑:Redis 锁超时与释放错乱
现代 Java 系统里,多实例部署很常见,分布式锁几乎是标配。但分布式锁用不好,也会导致一种“伪死锁”:线程 A 获取了 Redis 锁,但业务执行时间过长,锁超时自动过期了;线程 B 拿到锁开始执行;等 A 执行完,它去释放锁,释放的却是 B 的锁。这虽然不叫严格意义上的死锁,但会造成两个线程同时操作同一资源,后果可能比死锁还严重。
解决这类问题的标准做法是:在锁的 value 里存入一个唯一标识(比如 UUID),释放锁时用 Lua 脚本比对 value 一致后才删除。这是分布式锁的一个非常经典的实现细节。预防分布式死锁和资源争用,还需要注意给锁设置一个合理的过期时间,并且在持有锁的临界区里不要做太耗时的操作。
6. 别忽略那些“非典型”线索:锁膨胀、线程饥饿与 CPU 飙高之间的隐秘关联
6.1 锁竞争激烈居然也会让 CPU 变高
很多人以为死锁就是全部卡住、CPU 变低,但真实系统里,如果锁竞争非常激烈,CPU 反而可能升高。原因是:大量线程在尝试获取同一把锁时,会不断进行锁的“自旋”和上下文切换。Java 的 synchronized 锁在竞争不激烈时走偏向锁和轻量级锁,一旦竞争升级,会膨胀为重量级锁,线程会从用户态切换到内核态,被阻塞、唤醒,再切换。这些操作本身就要消耗 CPU 和内核资源。
你在 jstack 里可能会看到大量线程处于 BLOCKED 状态,同时 CPU 使用率却不低。这其实是一个很强的信号:不是死循环,而是锁竞争剧烈。处理方向是:减少锁持有时间、拆分锁粒度、使用读写锁或并发容器,甚至引入无锁数据结构(如 ConcurrentLinkedQueue、LongAdder 等),把这些线程从互相等待里解放出来。
6.2 线程饥饿:不一定死锁,但比死锁更隐蔽
死锁检测相对容易,因为有环结构很显眼。但“线程饥饿”问题,jstack 往往看不出明显异常。比如一个线程池里的线程全部被某个“慢任务”占用,新任务只能排队等待;或者使用公平锁时,某些线程因为优先级问题一直拿不到锁,长时间处于等待状态。表现就是系统整体吞吐下降、某个功能不可用,但 CPU 负载可能并不高。
这时候最好用的工具是线程池监控。你可以统计线程池的 activeCount、queueSize、completedTaskCount,如果队列堆积增长但线程数不涨,需要重点观察是不是核心线程数设置太小。Java 的 ThreadPoolExecutor 默认核心线程满了之后,任务进队列,队列满了才扩容到最大线程数。如果你的队列是无界队列(比如 LinkedBlockingQueue 默认构造),核心线程满后线程数永远不会扩容,任务只会无限堆积,内存也会出问题。这个问题在排查“为什么线程池没反应”时非常常见。
6.3 JVM 参数里藏着的一半答案
很多时候问题明明在 JVM 层,但表现形式和代码无关。比如堆内存设置过小,导致频繁 Full GC,CPU 自然飙高;又比如栈大小设置过大,导致每个线程占用的内存太多,太多线程创建不出来的同时,操作系统频繁换页。排查这类问题,要养成检查启动参数的习惯。-Xmx、-Xms、-XX:MaxMetaspaceSize、-XX:+UseG1GC、-XX:MaxGCPauseMillis 这些参数,都会直接影响 CPU 和内存的表现。
还有一点很容易被忽视:-XX:+HeapDumpOnOutOfMemoryError 这个参数,遇到 OOM 时能自动 dump 堆快照,后期分析非常有价值。同理,-XX:+ExitOnOutOfMemoryError 则会在 OOM 时直接让 JVM 退出,这样容器平台可以自动重启,避免一个已经“病入膏肓”的进程继续带病运行。这些参数平时就加上,远比故障时再想办法要强。
7. 我的完整排查清单:从报警到修复的半小时作战流程
最后把整个流程整合成一张可以直接照做的作战清单。这套流程我用了很多年,在多次 CPU 飙高和死锁事故里都派上了用场。
- 收到报警后冷静确认:先用
uptime看 load,free -h看内存,df -h看磁盘,排除不是磁盘满或内存泄漏导致的问题假象。 top -c锁定进程:找到高 CPU 的 Java 进程 PID,记录 CPU 使用率、内存占用、运行的时长。top -Hp定位线程:记录 CPU 占用最高的前 5 个线程 TID,并转成十六进制备用。- 连抽 jstack:间隔 5 秒连抽三次,保存到文件,同时记录时间点,方便和监控曲线对应。
- jstat 看 GC:通过
jstat -gcutil观察 GC 频率和耗时,判断是否由 GC 引起。 - 分析线程栈:重点关注 RUNNABLE 状态的线程栈顶;找
nid=对应的高 CPU 线程;对比三次栈是否一致。 - 判断死锁:检查 jstack 尾部是否有
Found one Java-level deadlock,如果有,按提示分析锁持有关系。 - 必要时上 Arthas:
thread -n 3快速定位,trace方法耗时,watch入参出参,动态分析无源码场景。 - 结合业务定位根因:根据栈里的类名、方法名,回到业务代码,分析是循环、正则、序列化、锁等待还是 GC 问题。
- 修复后验证:上线后观察 CPU 曲线、线程池活跃度、GC 曲线,确认问题不再复现;如果问题偶发,保留现场多个 dump 文件,后续持续分析。
在整个排查过程中,我个人的体会是:最快的排查路径,往往是先确认“死锁、GC、死循环、锁竞争”这四类问题中的哪一类,再决定用哪个工具深入。 很多时候你看完栈,只需要几分钟就能锁定位;但如果一上来就乱翻代码、乱试参数,很可能一整天都找不出来。工具本身不复杂,复杂度在于你能否快速把现场信息串成一条完整的证据链。
另外再分享一个小技巧:如果 CPU 飙高发生在容器环境里,注意看 top 里的 CPU 百分比是否是宿主机的全量核心数,还是容器配额对应的核心数。有时候容器明明只分配了 2 个核,但实际占满后,监控制度上看起来是 200%,那反而说明问题不大,线程数也不多;如果把宿主机 32 核全跑满,那才是真正的灾难。多了解一点容器 CPU 限制的原理,排查时就能少走不少弯路。