目录

Linux 线上排障实战:Java 服务 CPU 100% 的五步定位法

1

线上 CPU 打满时,最怕的不是问题本身,而是重启之后问题再也不复现。这篇文章复盘一次 86 秒的实操排障录屏:从 curl 卡死、CPU 100%,一路定位到 OrderService.java:11 这一行代码。整条链路上只有 5 条命令,但顺序不能乱。

一、现象与第一反应

终端里执行:

curl localhost:8080/buy

请求发起后一直挂住不返回,同时监控显示这台机器的 CPU 已经被一个 Java 服务吃满到 100%。

这时候最关键的一句话是:

千万别第一时间重启。 重启确实能让监控曲线降下来,但现场没了,问题可能过几分钟又再次触发,而你手里一点证据都没有。

正确的做法是先保护现场,再顺着"进程 → 线程 → 堆栈"三层往下钻。

二、排障主链路

一眼看完整条证据链:

系统负载  load average 7.61 / 6.35 / 5.56,  %Cpu(s) 99.5 us
   └─ 进程  PID 11119  java        CPU 396.4%
        └─ 线程  TID 11146  pool-1-thread-*   CPU 49.8%
             └─ 十六进制 2b8a  →  nid=0x2b8a  RUNNABLE
                  └─ 堆栈  OrderService.lambda$main$0(OrderService.java:11)

五步走:

  1. top —— 找到吃 CPU 的进程
  2. top -Hp <PID> —— 找到吃 CPU 的线程
  3. printf "%x\n" <TID> —— 十进制的线程号转成十六进制
  4. jstack <PID> | grep -A 5 -i "0x<hex>" —— 抓取该线程的堆栈
  5. 读堆栈 —— 看线程状态与具体代码行

三、实操过程

第 1 步:top 看进程

top

头部信息非常关键:

top - 16:43:01 up 2 days, 22:35,  1 user,  load average: 7.61, 6.35, 5.56
Tasks: 233 total,   1 running, 232 sleeping,   0 stopped,   0 zombie
%Cpu(s): 98.9 us,  0.8 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.3 si
MiB Mem :   7901.8 total,   5523.0 free,    498.7 used
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used

    PID USER      PR  NI    VIRT    RES  %CPU %MEM     TIME+ COMMAND
  11119 root      20   0 5741316 92760 396.4  1.1 572:27.55 java

三个信息直接给出判断:

  • %Cpu(s): 98.9 us、0.0 id → CPU 是被用户态程序占满的,不是 I/O 等待(wa 为 0);
  • 1 running 却有高达 7.61 的 load → 这是极少数线程在死跑,不是大量进程排队;
  • 排第一的就是 java,PID 11119,CPU 396.4%。

记下这个 PID —— 后面所有命令都要用它。

第 2 步:top -Hp 看线程

一个 Java 进程里可能跑着几十个线程,top 只给你进程的总和,看不出谁在作恶。加上 -H(Threads mode)按线程看:

top -Hp 11119

输出:

Threads:  34 total,   8 running,  26 sleeping,   0 stopped,   0 zombie
%Cpu(s):  99.5 us,  0.4 sy,  0.0 ni,  0.0 id

    PID USER      PR  NI    VIRT    RES  %CPU %MEM     TIME+ COMMAND
  11146 root      20   0 5741316 92760  49.8  1.1 165:16.76 pool-1-thre+
  11200 root      20   0 5741316 92760  49.8  1.1 101:32.36 pool-1-thre+
  11205 root      20   0 5741316 92760  49.8  1.1 100:35.23 pool-1-thre+
  11496 root      20   0 5741316 92760  49.8  1.1   2:33.30 pool-1-thre+
  11499 root      20   0 5741316 92760  49.8  1.1   2:23.09 pool-1-thre+
  11209 root      20   0 5741316 92760  49.5  1.1 100:59.05 pool-1-thre+
  11119 root      20   0 5741316 92760   0.0  1.1   0:01.01 java
  ...
  11122 root      20   0 5741316 92760   0.0  1.1   0:00.00 GC Thread#0
  11226 root      20   0 5741316 92760   0.0  1.1   0:02.27 G1 Service

挑一个 CPU 最高的就行,不用纠结:TID = 11146。

这里有个隐藏信息值得注意:34 total 里有 8 个 pool-1-thread-* 全部跑到 ~49.8%。8 × 49.8% ≈ 398%,正好等于第 1 步看到的进程级 396.4%。

也就是说:不是某个单例线程在空转,而是整个线程池(8 个工作线程)被同一段业务代码同时拖住了。

第 3 步:线程号转十六进制

top 显示的是十进制 TID,而 jstack 里的线程标识是十六进制的 nid=0x...,所以要先转一下,否则 grep 不到:

printf "%x\n" 11146
# 2b8a

第 4 步:jstack 抓现场

jstack 11119 | grep -A 5 -i "0x2b8a"

-A 5 是为了把匹配行之后的 5 行调用栈一起带出来:

"pool-1-thread-1" #16 prio=5 os_prio=0 cpu=994523.19ms elapsed=11592.52s tid=0x00007f4128005ba0 nid=0x2b8a runnable  [0x00007f41d0942000]
   java.lang.Thread.State: RUNNABLE
        at OrderService.lambda$main$0(OrderService.java:11)
        at OrderService$$Lambda$206/0x00007f417c140208.handle(Unknown Source)
        at com.sun.net.httpserver.Filter$Chain.doFilter(...)
        at sun.net.httpserver.AuthFilter.doFilter(...)

第 5 步:读堆栈

一行一行拆:

字段 值 说明
线程名 pool-1-thread-1 来自 Executors 固定的线程池,第 1 号工作线程
cpu= 994523.19ms(≈16.6 分钟) 该线程累计消耗的 CPU 时间
elapsed= 11592.52s(≈3.2 小时) 该线程自启动以来的存活时间
nid= 0x2b8a 与我们上一步转换出来的十六进制一致 ✔
State RUNNABLE 正在真正执行,不是 sleep、不是等锁、不是等 I/O
栈顶 OrderService.lambda$main$0(OrderService.java:11) 业务代码,第 11 行

cpu ≈ elapsed 意味着这个线程从出生起几乎100% 的时间都在占 CPU,配合 RUNNABLE,基本可以排除"数据库慢查询卡死""锁竞争"这类阻塞型问题。

到这里,证据链就完整了。

四、根因与结论

请求 /buy 打到 OrderService 注册的 HTTP handler(一个 lambda,位于 OrderService.java 第 11 行),这段代码里存在死循环或忙等待(busy loop / busy wait)的逻辑:

  1. 线程池的 8 个工作线程全部进入同一个死循环,
  2. CPU 被 8 × ~50% 打满到 100%,
  3. 线程池再也没有空闲线程处理新请求,
  4. 于是 curl localhost:8080/buy 一直挂住 —— 这是现象,不是原因。

排查的最后一步(对应录屏结尾的那句话):

如果业务量并不大,那就要看这里有没有死循环或者逻辑上的问题。

业务量不大却 CPU 打满,几乎只有三种可能:死循环 / 忙等、正则灾难性回溯、无节制的自旋重试。本案属于第一种。

五、可复用的排障速查卡

# 1. 找进程
top
# 2. 找线程(-H = threads)
top -Hp <PID>
# 3. 十进制 TID → 十六进制
printf "%x\n" <TID>
# 4. 抓栈
jstack <PID> | grep -A 5 -i "0x<hex>"
# 5. 多条命令一把梭(进阶)
jstack <PID> > /tmp/js.txt   # 先落地,避免瞬间状态抓不到
pidstat -t -p <PID> 1 5      # 更精确的线程级 CPU

几个容易踩的坑:

  • 别重启。重启等于销毁唯一的现场,复发前你什么也证明不了。
  • top 的 TID 是十进制,jstack 的 nid 是十六进制,漏了转换就 grep 不到。
  • -A 5 不能省,否则只有一行匹配,看不到调用栈。
  • 多抓几次。死循环位置可能随入参漂移,jstack 连抓 3 次对比更准。
  • 看清线程名。pool-1-thread-* 全满 = 线程池被打穿;只有一个线程异常 = 单点逻辑问题。

六、进阶:还能更快

  • pidstat -t -p <PID> 1 直接按线程出 CPU,比 top -Hp 更适合复制粘贴;
  • top -H -b -n 1 | head -20 适合脚本化采集;
  • 有 arthas 的环境可以直接 thread -n 3 一步定位最忙线程并打印栈,或者 thread <tid>;
  • 生产上建议加个 CPU 超过阈值自动 jstack 的钩子,把现场自动化保存下来。

附:本次排障的时间线

阶段 动作 结论
0–12s curl /buy 卡死,CPU 100% 不重启,保留现场
12–26s top java PID 11119,396.4% CPU
26–40s top -Hp 11119 8 个 pool-1-thread-* 各占 ~50%,取 TID 11146
40–48s printf "%x\n" 11146 → 2b8a 十进制转十六进制
48–58s jstack 11119 \| grep -A 5 "0x2b8a" 命中 nid=0x2b8a,RUNNABLE
58–86s 读栈 OrderService.java:11,死循环/逻辑问题

复盘来源:一段 86 秒的线上排障实操录屏(Xshell 终端 + 字幕讲解),环境为 8 核 Linux,Java 服务监听 8080,关键接口为 /buy。