面试官:如何定位和解决CPU 使用率过高问题？

天天摸鱼的java工程师
726 阅读5分钟

作为一名有着八年 Java 开发经验的老兵，我经历过多次线上系统 CPU 飙升的紧急情况。记得在某电商平台的促销活动中，服务器 CPU 使用率突然达到 100%，整个系统几乎瘫痪。通过这次惨痛教训，我总结出一套行之有效的 CPU 问题排查方法论。本文将结合实际案例，分享我在高并发场景下定位和解决 CPU 使用率过高问题的经验。

一、问题现象：系统突然变慢

在一次电商大促活动中，我们的支付系统出现了严重的性能问题：

  • 用户反馈支付请求响应缓慢，甚至出现超时

  • 监控系统显示服务器 CPU 使用率持续超过 90%

  • 部分服务开始返回 500 错误

这种情况在高并发场景下非常常见，可能由多种原因引起，如死循环、线程阻塞、GC 频繁等。接下来，我将详细介绍如何一步步定位和解决这类问题。

二、排查流程：从宏观到微观

1. 确认 CPU 高负载

首先需要确认确实是 Java 进程导致的 CPU 使用率过高。可以使用top命令查看系统整体 CPU 使用情况：

top -c

按P键（大写）按照 CPU 使用率排序，找到占用 CPU 最高的 Java 进程 ID（PID）。

2. 定位具体线程

使用top -Hp <PID>命令查看该 Java 进程内所有线程的 CPU 使用情况：

top -Hp 12345  # 12345是Java进程ID

同样按P键排序，找到占用 CPU 最高的线程 ID（TID）。

3. 线程 ID 转换为 16 进制

由于 Java 堆栈信息中线程 ID 是 16 进制表示的，需要将十进制的 TID 转换为 16 进制：

printf "%x\n" 12346  # 假设12346是占用CPU最高的线程ID

假设输出结果是303a。

4. 导出 Java 线程堆栈

使用jstack命令导出 Java 进程的线程堆栈信息：

jstack 12345 > thread_dump.txt

5. 在线程堆栈中定位问题线程

在导出的thread_dump.txt文件中搜索步骤 3 中得到的 16 进制线程 ID（303a）：

grep -A 30 '0x303a' thread_dump.txt

这将显示该线程的详细堆栈信息，通常能找到导致 CPU 高的具体代码位置。

6. 分析 GC 情况（如果必要）

如果怀疑是 GC 导致的 CPU 高，可以使用jstat命令查看 GC 情况：

jstat -gcutil 12345 1000 10  # 每1秒输出一次，共输出10次

如果发现频繁的 Full GC，需要进一步分析堆内存使用情况。

三、常见问题及解决方法

1. 死循环问题

死循环是导致 CPU 使用率过高的常见原因之一。下面是一个模拟死循环的代码示例：

public class InfiniteLoopExample {
    public static void main(String[] args) {
        // 启动一个线程执行死循环
        new Thread(() -> {
            while (true) { // 死循环，会导致CPU使用率飙升
                // 模拟复杂计算
                Math.pow(999, 999);
            }
        }, "InfiniteLoopThread").start();

        // 主线程继续执行其他任务
        System.out.println("Main thread is running...");
    }
}

排查方法：

  • 使用上述步骤定位到具体线程

  • 在线程堆栈中会看到类似以下信息：

    "InfiniteLoopThread" #12 prio=5 os_prio=0 tid=0x00007f9c4c0a2000 nid=0x303a runnable [0x00007f9c43ffd000]
   java.lang.Thread.State: RUNNABLE
       at java.lang.Math.pow(Math.java:662)
       at InfiniteLoopExample.lambda$main$0(InfiniteLoopExample.java:8)
       at InfiniteLoopExample$$Lambda$1/12345678.run(Unknown Source)
       at java.lang.Thread.run(Thread.java:748)

    可以看到线程正在执行Math.pow方法，并且状态为RUNNABLE。

解决方法：

  • 检查代码逻辑，确保循环有正确的终止条件
  • 添加适当的条件判断或超时机制

2. 锁竞争问题

锁竞争也可能导致 CPU 使用率过高，尤其是在高并发场景下。下面是一个模拟锁竞争的代码示例：

public class LockContentionExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        // 创建10个线程竞争同一把锁
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                while (true) {
                    synchronized (lock) {
                        // 模拟耗时操作
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "LockThread-" + i).start();
        }
    }
}

排查方法：

  • 使用jstack导出线程堆栈

  • 查看堆栈中是否有大量线程处于BLOCKED状态，等待获取同一把锁

    "LockThread-1" #13 prio=5 os_prio=0 tid=0x00007f9c4c0a4800 nid=0x303b waiting for monitor entry [0x00007f9c43f7c000]
   java.lang.Thread.State: BLOCKED (on object monitor)
       at LockContentionExample.lambda$main$0(LockContentionExample.java:12)
       - waiting to lock <0x000000076b4c2a50> (a java.lang.Object)
       at LockContentionExample$$Lambda$1/12345679.run(Unknown Source)
       at java.lang.Thread.run(Thread.java:748)

解决方法：

  • 减少锁的粒度，只在必要的代码块加锁
  • 使用更细粒度的锁，如ReentrantLock
  • 考虑使用无锁数据结构，如ConcurrentHashMap

3. 正则表达式性能问题

复杂的正则表达式也可能导致 CPU 使用率过高。下面是一个模拟正则表达式性能问题的代码示例：

public class RegexPerformanceExample {
    private static final String REGEX = "^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$";

    public static void main(String[] args) {
        // 启动一个线程执行大量正则表达式匹配
        new Thread(() -> {
            while (true) {
                // 模拟验证大量邮箱地址
                for (int i = 0; i < 1000; i++) {
                    "test" + i + "@example.com".matches(REGEX);
                }
            }
        }, "RegexThread").start();
    }
}

排查方法：

  • 定位到具体线程

  • 在线程堆栈中会看到类似以下信息：

    "RegexThread" #12 prio=5 os_prio=0 tid=0x00007f9c4c0a2000 nid=0x303a runnable [0x00007f9c43ffd000]
   java.lang.Thread.State: RUNNABLE
       at java.util.regex.Pattern$Curly.match0(Pattern.java:4117)
       at java.util.regex.Pattern$Curly.match(Pattern.java:4092)
       at java.util.regex.Pattern$GroupTail.match(Pattern.java:4746)
       at java.util.regex.Pattern$BranchConn.match(Pattern.java:4683)
       at java.util.regex.Pattern$CharProperty.match(Pattern.java:3776)
       at java.util.regex.Pattern$Branch.match(Pattern.java:4720)
       at java.util.regex.Pattern$GroupHead.match(Pattern.java:4783)
       at java.util.regex.Pattern$Loop.match(Pattern.java:4955)
       at java.util.regex.Pattern$GroupTail.match(Pattern.java:4746)
       at java.util.regex.Pattern$BranchConn.match(Pattern.java:4683)
       at java.util.regex.Pattern$CharProperty.match(Pattern.java:3776)
       ...

解决方法：

  • 优化正则表达式，避免使用复杂的回溯模式

  • 缓存Pattern对象，避免重复编译正则表达式

    private static final Pattern EMAIL_PATTERN = Pattern.compile(
    "^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$"
);

// 使用预编译的Pattern对象
Matcher matcher = EMAIL_PATTERN.matcher(email);
boolean isValid = matcher.matches();

四、工具推荐

1. 命令行工具

  • top：查看系统整体 CPU 使用情况
  • top -Hp：查看 Java 进程内线程的 CPU 使用情况
  • jstack：导出 Java 线程堆栈信息
  • jstat：监控 JVM 统计信息，如 GC 情况
  • jmap：生成堆转储快照（heap dump）
  • jhat：分析堆转储快照
  • perf：Linux 性能分析工具，可用于分析 CPU 热点

2. 图形化工具

  • VisualVM：集成多种 JDK 工具的可视化工具，可监控 CPU、内存、线程等
  • YourKit：强大的 Java 性能分析工具，可深入分析 CPU、内存问题
  • JProfiler：专业的 Java 性能分析工具，支持远程监控和采样
  • GraalVM VisualVM：基于 VisualVM 的增强版，支持 GraalVM 和原生镜像

五、预防措施

为了避免高并发场景下的 CPU 问题，建议在开发和测试阶段采取以下预防措施：

  1. 代码审查：检查代码中是否存在潜在的死循环、过度同步等问题
  2. 性能测试：在压测环境中模拟高并发场景，提前发现性能瓶颈
  3. 监控系统：完善监控系统，实时监控 CPU、内存、线程等指标
  4. 设置告警：设置合理的告警阈值，及时发现异常情况
  5. 限流熔断：在高并发场景下，使用限流和熔断机制保护系统

六、总结

高并发场景下的 CPU 使用率过高问题是 Java 开发者经常遇到的挑战。通过本文介绍的排查流程和工具，结合实际案例分析，我们可以快速定位和解决这类问题。关键是要建立一套系统化的排查方法，从宏观到微观逐步定位问题，同时注重预防措施，避免问题在生产环境中出现。

avatar
文章
阅读
粉丝