Linux环境下Jar包多线程代码触发JVM致命错误求助

Hi Paul,

Let's break down this frustrating JVM fatal error you're facing. The SIGSEGV crash in PSPromotionManager::copy_to_survivor_space points straight to a problem in the JVM's garbage collection (GC) subsystem—specifically the Parallel Scavenge collector's logic for copying live objects to the Survivor space during Young GC. Here's what might be causing it, plus actionable steps to diagnose and fix the issue:

• Outdated JVM Version Bug: You're running Java 8u201, a 2019 release that has known stability flaws in the Parallel Scavenge collector, especially around multi-threaded object copying during GC. Many of these bugs have been patched in later Java 8 updates or newer LTS releases like Java 11/17.
• Misconfigured Heap Memory: If your Young/Survivor space is too small, it can trigger excessive GC cycles that push the JVM into edge-case memory handling. Or if your total heap (-Xmx) exceeds the system's available physical memory/swap, it can lead to invalid memory accesses that trigger SIGSEGV.
• System/Hardware Issues: Underlying problems like faulty RAM modules, CPU cache inconsistencies, or Linux kernel memory management bugs can cause the JVM to hit segmentation faults when accessing memory addresses.
• Indirect Code Triggers: Even if the crash log doesn't directly reference your code, extreme multi-threaded scenarios (e.g., rapid object creation/destruction, unsafe JNI code, or leaky object references) can trigger latent bugs in the JVM's core GC logic.

• Upgrade Your JVM First: This is the most likely quick fix. Upgrade to the latest Java 8 update (like u391) or switch to Java 11/17 LTS. Newer versions include extensive fixes for GC-related crashes, and this will resolve the issue if it's a known JVM bug.
• Tweak GC Configuration:
  • Try switching to the G1GC collector instead of Parallel Scavenge by adding this startup flag: java -XX:+UseG1GC -jar your-application.jar
  • Adjust heap and survivor space settings: Increase the total heap with -Xmx4g -Xms4g (tune this to match your system's available memory), or adjust the Survivor ratio with -XX:SurvivorRatio=6 (lower values mean larger Survivor spaces to reduce GC pressure)
  • Enable detailed GC logging to spot patterns before crashes: -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:/var/log/gc.log
• Check System & Hardware:
  • Verify system memory with the free -h command—make sure your JVM heap doesn't exceed available physical memory
  • Run a memory test (like memtest86+) to rule out faulty RAM modules
  • Update your Linux kernel to a stable, recent version to avoid kernel-level memory management bugs
• Audit Your Application Code:
  • If you use JNI native code, check for memory leaks or invalid memory access in those modules—these can corrupt the JVM's memory space and trigger crashes
  • Look for multi-threaded code that creates an unusual number of short-lived objects, or static collections holding onto objects unnecessarily (this increases GC pressure and can push the JVM into buggy edge cases)
  • Try reducing the number of threads temporarily to see if the crash stops—this can help isolate if the issue is tied to extreme concurrency

You mentioned having 4 VM error logs—these contain critical details to narrow down the issue further. Focus on these sections in the logs:

• GC history immediately before the crash: Are there frequent Young GCs or unexpected Full GCs happening?
• The thread stack trace for the crashing thread: Is there a repeating pattern across all 4 logs?
• Physical memory usage stats: Does the system run out of memory right before the crash?

If upgrading the JVM and adjusting settings doesn't fix the problem, share key snippets from those logs (like the full error stack and pre-crash GC stats) and we can dig deeper.

内容的提问来源于stack exchange，提问作者user8444746