JAVA程序随机卡死：死循环、锁等待与CPU单核占满排查

大家好，今天我们来聊聊Java程序随机卡死的问题，重点关注死循环、锁等待和CPU单核占满这几个常见原因。随机卡死意味着问题不是稳定复现，而是偶发性的，这给排查带来了相当的难度。

一、随机卡死的常见诱因

在深入排查方法之前，我们先了解一下可能导致Java程序随机卡死的一些常见诱因。

死循环： 这是最直接的原因之一。程序进入一个无法跳出的循环，导致CPU资源被持续占用，最终表现为卡死。
锁竞争与死锁： 多线程环境下，不合理的锁使用会导致线程互相等待，形成死锁或者长时间的锁竞争，从而阻塞程序的正常运行。
内存泄漏： 虽然内存泄漏通常不会直接导致卡死，但长时间的内存泄漏会导致系统资源耗尽，最终也可能引发程序崩溃或卡死。
外部资源瓶颈： 对数据库、网络等外部资源的访问如果出现阻塞，也可能导致程序hang住。
JVM Bug： 虽然概率较低，但JVM本身也可能存在bug，导致程序在特定条件下出现问题。
GC问题： 频繁Full GC可能会导致程序STW(Stop The World)，如果GC时间过长，也会表现为程序卡顿甚至卡死。

二、排查思路与常用工具

面对随机卡死的问题，我们需要系统化的排查思路和合适的工具。

监控与日志： 完善的监控和日志体系是解决问题的关键。包括CPU、内存、线程状态、GC情况等关键指标的监控，以及详细的业务日志和异常日志。
jstack： 用于生成Java线程快照，可以帮助我们分析线程状态，定位死锁和锁等待。
jmap： 用于生成Java堆快照，可以帮助我们分析内存使用情况，定位内存泄漏。
jstat： 用于监控JVM的各种统计信息，包括GC、类加载等。
VisualVM/JConsole： 图形化的JVM监控工具，可以方便地查看线程状态、内存使用情况等。
Arthas： Alibaba开源的Java诊断工具，功能强大，可以动态地查看和修改程序状态。
火焰图（Flame Graph）： 用于分析CPU使用情况，可以帮助我们定位CPU瓶颈。

三、死循环的排查与定位

死循环是最容易导致CPU单核占满的罪魁祸首。

1. CPU占用率监控： 使用top命令（Linux）或任务管理器（Windows）观察CPU占用率。如果发现某个Java进程的CPU占用率持续接近100%，并且只有一个核被占满，那么很可能存在死循环。

2. jstack分析线程状态：

使用jps命令找到Java进程的ID。
使用jstack <pid>命令生成线程快照。
在线程快照中查找状态为RUNNABLE的线程，特别关注那些CPU时间占用较高的线程。

观察线程的堆栈信息，尝试找到循环的代码。

示例代码：

public class DeadLoop {
   public static void main(String[] args) {
       while (true) { // 故意制造死循环
           // do nothing
       }
   }
}

使用jstack分析，可能会看到类似这样的堆栈信息：

"main" #1 prio=5 os_prio=0 tid=0x00007f9c78009800 nid=0x7b03 runnable [0x00007f9c78e08000]
  java.lang.Thread.State: RUNNABLE
       at DeadLoop.main(DeadLoop.java:4)

DeadLoop.java:4 指明了死循环的位置。

3. Arthas 实时诊断：

Arthas 提供了更强大的诊断功能，可以在不重启应用的情况下，查看方法的执行耗时、参数和返回值。

使用thread命令查看线程状态，找出CPU使用率最高的线程。
使用stack <tid>命令查看指定线程的堆栈信息。
使用trace <class name> <method name>命令跟踪方法的执行情况，查看耗时。

例如：trace DeadLoop main

4. 日志排查：

如果程序中存在循环，并且循环中包含日志输出，可以观察日志输出的频率。如果日志输出非常频繁，并且没有停下来的迹象，那么很可能存在死循环。

四、锁等待与死锁的排查与定位

锁竞争和死锁会导致线程阻塞，最终表现为程序卡死。

1. jstack 分析线程状态：

使用jstack <pid>命令生成线程快照。
查找状态为BLOCKED或WAITING的线程。
观察这些线程的堆栈信息，找到它们正在等待的锁。

分析代码，找出持有这些锁的线程，以及它们持有锁的时间。

示例代码 (死锁):

public class DeadLockExample {
   private static final Object lock1 = new Object();
   private static final Object lock2 = new Object();

   public static void main(String[] args) {
       Thread thread1 = new Thread(() -> {
           synchronized (lock1) {
               System.out.println("Thread 1: Holding lock1...");
               try { Thread.sleep(10); } catch (InterruptedException e) {}
               System.out.println("Thread 1: Waiting for lock2...");
               synchronized (lock2) {
                   System.out.println("Thread 1: Holding lock1 & lock2...");
               }
           }
       });

       Thread thread2 = new Thread(() -> {
           synchronized (lock2) {
               System.out.println("Thread 2: Holding lock2...");
               try { Thread.sleep(10); } catch (InterruptedException e) {}
               System.out.println("Thread 2: Waiting for lock1...");
               synchronized (lock1) {
                   System.out.println("Thread 2: Holding lock1 & lock2...");
               }
           }
       });

       thread1.start();
       thread2.start();
   }
}

使用jstack分析，可能会看到类似这样的信息：

"Thread-1" #11 prio=5 os_prio=0 tid=0x00007f9c78a78800 nid=0x7b0a waiting for monitor entry [0x00007f9c795c8000]
  java.lang.Thread.State: BLOCKED (on object monitor)
       at DeadLockExample.lambda$main$1(DeadLockExample.java:24)
       - waiting to lock <0x000000076b010030> (a java.lang.Object)
       - locked <0x000000076b010020> (a java.lang.Object)

"Thread-0" #10 prio=5 os_prio=0 tid=0x00007f9c78a77800 nid=0x7b09 waiting for monitor entry [0x00007f9c794c7000]
  java.lang.Thread.State: BLOCKED (on object monitor)
       at DeadLockExample.lambda$main$0(DeadLockExample.java:14)
       - waiting to lock <0x000000076b010020> (a java.lang.Object)
       - locked <0x000000076b010030> (a java.lang.Object)

Found one Java-level deadlock:
=============================
"Thread-1":
 waiting to lock monitor 0x00007f9c78009800 (object 0x000000076b010030, a java.lang.Object),
 which is held by "Thread-0"
"Thread-0":
 waiting to lock monitor 0x00007f9c78008800 (object 0x000000076b010020, a java.lang.Object),
 which is held by "Thread-1"

jstack会明确指出存在死锁，并给出相关线程和锁的信息。

2. VisualVM/JConsole：

这些工具可以图形化地展示线程状态，方便观察锁竞争和死锁。它们通常会提供死锁检测功能，可以自动检测出死锁并给出提示。

3. Arthas 线程监控：

Arthas 提供了thread -b命令，可以找出当前最忙碌的线程，方便定位锁竞争问题。

4. 代码审查：

仔细审查代码中锁的使用，特别是多线程并发访问共享资源的部分，检查是否存在死锁的可能，以及是否可以优化锁的使用，减少锁竞争。

五、内存泄漏的排查与定位

内存泄漏会导致JVM堆内存持续增长，最终可能导致程序崩溃或卡死。

1. 监控JVM堆内存使用情况： 使用监控工具（如Grafana、Prometheus等）监控JVM堆内存的使用情况。如果发现堆内存持续增长，并且没有下降的趋势，那么很可能存在内存泄漏。

2. jmap 生成堆快照：

使用jmap -dump:format=b,file=heapdump.bin <pid>命令生成堆快照。
使用MAT (Memory Analyzer Tool) 或 VisualVM 等工具打开堆快照。
分析堆快照，找出占用内存最多的对象。

分析对象的引用链，找出导致对象无法被垃圾回收的原因。

示例代码 (简单的内存泄漏):

import java.util.ArrayList;
import java.util.List;

public class MemoryLeakExample {
   private static List<Object> list = new ArrayList<>();

   public static void main(String[] args) throws InterruptedException {
       while (true) {
           Object obj = new Object();
           list.add(obj); // 添加到静态列表中，无法被回收
           Thread.sleep(10);
       }
   }
}

使用MAT打开堆快照，可以很容易地发现MemoryLeakExample类的静态列表list占用了大量的内存。

3. VisualVM/JConsole：

这些工具可以实时监控JVM堆内存的使用情况，并提供了一些简单的内存泄漏检测功能。

4. 代码审查：

仔细审查代码，特别是集合的使用，检查是否存在对象被添加到集合后，没有被及时移除的情况。关注单例模式，确保单例对象中的资源能被正确的释放。检查资源是否被正确关闭（如文件流、数据库连接等）。

六、外部资源瓶颈的排查

程序对外部资源的访问如果出现阻塞，也可能导致卡死。

1. 监控外部资源： 监控数据库、网络等外部资源的使用情况，例如数据库连接数、网络延迟等。

2. 分析线程状态： 使用jstack命令生成线程快照，观察线程的堆栈信息，找出正在等待外部资源的线程。

3. 日志分析： 查看程序日志，找出与外部资源相关的错误信息或慢查询日志。

4. 使用工具： 使用数据库监控工具、网络监控工具等，分析外部资源的性能瓶颈。

七、 JVM Bug 的排查

虽然概率较低，但JVM本身也可能存在bug，导致程序在特定条件下出现问题。

1. 升级JVM版本： 升级到最新的JVM版本，可以修复一些已知的bug。

2. 搜索相关bug报告： 在JVM相关的论坛或bug跟踪系统中搜索相关的bug报告，看看是否有类似的问题。

3. 简化代码： 尝试简化代码，缩小问题范围，看看是否可以重现bug。

4. 联系JVM厂商： 如果怀疑是JVM bug，可以联系JVM厂商，寻求技术支持。

八、 GC 问题排查

频繁Full GC可能会导致程序STW(Stop The World)，如果GC时间过长，也会表现为程序卡顿甚至卡死。

1. jstat 监控GC:

使用 jstat -gcutil <pid> 1000 命令，可以每隔1000ms输出GC的信息，观察Full GC的频率和耗时。

2. GC 日志:

开启GC日志，分析GC日志，可以更详细地了解GC的过程。

-Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=10M

3. 调整GC策略:

根据应用的特点，调整GC策略，例如选择合适的GC算法、调整堆大小等。减少不必要的对象创建，尽量复用对象。避免在短时间内创建大量临时对象。

代码层面优化与预防措施

避免死循环： 在循环中加入合理的退出条件，并进行充分的测试。
合理使用锁： 避免死锁，尽量使用细粒度的锁，减少锁的持有时间。使用try-lock避免无限等待。
及时释放资源： 确保资源（如文件流、数据库连接等）在使用完毕后被及时释放。使用try-with-resources语句可以自动释放资源。
避免内存泄漏： 避免将对象添加到静态集合中，或者在使用完毕后及时从集合中移除。
代码审查： 定期进行代码审查，检查代码中是否存在潜在的问题。
单元测试： 编写充分的单元测试，确保代码的正确性。

随机卡死是长期斗争，需要耐心，积累经验

随机卡死的问题往往比较复杂，排查起来需要耐心和经验。我们需要充分利用各种工具，结合日志和监控数据，逐步缩小问题范围，最终找到问题的根源。同时，我们也需要在日常开发中，注意代码质量，避免潜在的问题，才能从根本上减少随机卡死的发生。

JAVA程序随机卡死：死循环、锁等待与CPU单核占满排查

发表回复 取消回复

发表回复取消回复