JvisualVM：应用程序CPU占用缓慢增长异常求助

Hey there, let’s walk through how to diagnose this slow CPU creep you’re seeing in your app—even when no memory leaks are showing up in JVisualVM. I’ve tackled similar issues before, so here’s a structured approach to get to the root cause:

1. Dig into JVisualVM’s CPU Profiling/Sampling Data #

• Use the Sampler or Profiler tab to track CPU usage over extended periods (not just snapshots). Focus on methods whose invocation time or call count keeps rising over the 2h→20h→22h window.
• Pay attention to:
  • Frequent garbage collection (GC) pauses—even without leaks, repeated minor GCs or fragmented old gen can eat into CPU.
  • Threads stuck in RUNNABLE state running unnecessary loops, or growing counts of WAITING/TIMED_WAITING threads that might indicate resource contention.

2. Audit GC-Related CPU Overhead #

• In JVisualVM’s Memory tab, enable GC monitoring to check if GC frequency or duration increases over time. A slow rise in GC activity often correlates with CPU creep.
• Add these JVM flags to capture detailed GC logs:

  -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:./gc.log
  

  Use tools like GCViewer to analyze the logs—look for increasing pause times or rising allocation rates that aren’t matched by efficient collection.

3. Check for Thread-Related Issues #

• Monitor thread count trends in JVisualVM’s Thread tab. Are threads failing to terminate (e.g., background tasks, scheduled jobs)? A growing thread pool can lead to context-switching overhead that ramps up CPU usage.
• Diagnose lock contention: Use jstack to take thread dumps at 2h, 20h, and 22h, then compare them. Look for threads waiting on the same locks more frequently over time. JVisualVM’s Profiler can also highlight hotspots in java.util.concurrent.locks methods.

4. Rule Out External Resource Bottlenecks #

• If your app calls external services, databases, or caches: Check if their response times degrade over time. Slow external calls can lead to repeated retries, timeout waits, or thread blocking that indirectly increases CPU usage. Cross-reference with your app’s error/timeout logs.
• Verify resource cleanup: Ensure database connections, file handles, and network sockets are properly closed. Leaking these (even without memory leaks) can force your app to repeatedly recreate resources, adding CPU overhead.

5. Hunt for Code-Level Hotspots #

• Look for loops that scale with time: For example, a cache that grows indefinitely—each traversal of the cache will take longer as entries accumulate, driving up CPU usage.
• Check dynamic code generation: If your app uses reflection, proxies, or runtime code generation, ensure these aren’t creating new classes on every request. Frequent class loading/unloading is a hidden CPU hog.

内容的提问来源于stack exchange，提问作者Liubov E.