How to Minimize Long GC Pauses in Java Applications

Garbage collection (GC) is essential for Java applications, but poorly managed GC can become a performance killer. This article lists the main causes of long GC pauses and provides actionable solutions to keep pause times short.

1. High Object Creation Rate

When an application creates objects rapidly, the GC must work harder, increasing pause times. Use profiling tools such as JProfiler, YourKit, or JVisualVM to identify which objects are created, their allocation rate, memory footprint, and the code paths responsible. Optimize the code to reduce the creation of high‑memory objects.

Tip: Measuring Object Creation Rate

Upload your GC logs to the GCeasy analyzer; the "Average Creation Rate" metric should be kept low (e.g., 8.83 MB/sec in the example).

2. Insufficient Young Generation Space

A small young generation forces objects to be promoted to the old generation too early, where collection is slower. Increase the young generation size using either -Xmn (direct size) or -XX:NewRatio (ratio to the old generation). For example, -XX:NewRatio=2 makes the young generation one‑third of the heap.

3. Choosing the Right GC Algorithm

The GC algorithm heavily influences pause times. For most users, G1 GC is recommended because it can auto‑tune. You can set an expected maximum pause with the JVM flag -XX:MaxGCPauseMillis=200 .

4. Process Using Swap

When the OS swaps out memory, GC pauses increase dramatically. Production services should never swap. Use the following Bash script to detect processes that are swapping and take corrective actions (add more RAM, reduce process count, or shrink the heap).

#!/bin/bash
SUM=0
OVERALL=0
for DIR in `find /proc/ -maxdepth 1 -type d -regex "^/proc/[0-9]+"`; do
  PID=`echo $DIR | cut -d / -f 3`
  PROGNAME=`ps -p $PID -o comm --no-headers`
  for SWAP in `grep VmSwap $DIR/status 2>/dev/null | awk '{ print $2 }'`; do
    let SUM=$SUM+$SWAP
  done
  if (( $SUM > 0 )); then
    echo "PID=$PID swapped $SUM KB ($PROGNAME)"
  fi
  let OVERALL=$OVERALL+$SUM
  SUM=0
done
echo "Overall swap used: $OVERALL KB"

If swapping is detected, consider adding RAM, reducing the number of processes, or decreasing the heap size (with caution).

5. Tuning GC Thread Count

Inspect GC logs for user , sys , and real times. If real is not much lower than user , you may need more GC threads. For example, with a 25 s user time and 5 GC threads, the real time should approach 5 s. Beware that too many threads increase CPU usage.

6. Background I/O Activity

Heavy filesystem I/O can also cause long GC pauses. Identify whether the I/O originates from your application or other processes. Mitigation strategies include optimizing the application's I/O, stopping other high‑I/O processes, or moving the application to a less busy server.

Tip: Monitoring I/O

On Unix‑like systems, use the SAR command to monitor I/O, e.g., sar -d -p 1 , which reports read/write statistics every second.

7. System.gc() Calls

Explicit calls to System.gc() or Runtime.getRuntime().gc() trigger a stop‑the‑world Full GC, freezing the JVM. These calls may come from developers, third‑party libraries, JMX tools, or RMI. Disable them when unnecessary with -XX:+DisableExplicitGC or adjust RMI GC intervals via -Dsun.rmi.dgc.server.gcInterval=n and -Dsun.rmi.dgc.client.gcInterval=n .

Tip: Detecting System.gc() Invocations

Upload GC logs to GCeasy and look for the GCCauses section; it will list how many times System.gc() was triggered.

Warning : All strategies should be thoroughly tested before applying to production, as improper tuning can have adverse effects.

Source: http://suo.im/5rWXNb