Articles

JVM Performance Flags: Every -XX Option That Matters (2026)

April 18, 2026 6 min read

The JVM’s performance flags, prefixed with -XX:, aren’t just knobs to twiddle; they’re direct instructions to the Java runtime about how to manage its core operations, from memory allocation to thread scheduling, and understanding them is key to unlocking serious performance gains.

Let’s watch the JVM in action with some of these flags. Imagine a simple Java application that generates a lot of objects and then discards them. Without specific flags, the garbage collector might thrash, pausing the application frequently.

public class ObjectGenerator {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Starting object generation...");
        for (int i = 0; i < 10000000; i++) {
            new byte[1024]; // Allocate 1KB object
            if (i % 100000 == 0) {
                System.out.println("Generated " + i + " objects...");
                Thread.sleep(10); // Short pause to observe
            }
        }
        System.out.println("Finished object generation. Waiting for GC...");
        Thread.sleep(5000); // Give GC time to run
        System.out.println("Exiting.");
    }
}

Now, let’s consider how some -XX flags can dramatically alter the behavior of this simple program. The primary areas -XX flags address are:

  • Garbage Collection (GC): How memory is reclaimed.
  • Heap Management: How the JVM allocates and structures memory.
  • JIT Compilation: How Java bytecode is converted to native machine code.
  • Threading: How the JVM manages threads.

Garbage Collection Tuning

The most impactful -XX flags often relate to the garbage collector. The JVM offers several GC algorithms, each with different performance characteristics.

1. -XX:+UseG1GC (Garbage-First Garbage Collector)

  • What it does: Enables the Garbage-First (G1) collector, which aims for a good balance between throughput and latency by dividing the heap into regions and prioritizing collection in regions with the most garbage.
  • Why it matters: G1 is the default in modern JVMs (Java 9+) for a reason. It’s generally a good all-rounder, especially for applications with large heaps and a need for predictable pause times.
  • How to use: java -XX:+UseG1GC YourApp

2. -XX:MaxGCPauseMillis=200

  • What it does: Sets a target maximum pause time for the garbage collector. G1 (and others) will attempt to meet this goal, though it’s not a hard guarantee.
  • Why it matters: For latency-sensitive applications, this is crucial. The GC will work harder to stop the application for shorter durations.
  • How to use: java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 YourApp

3. -XX:NewRatio=2

  • What it does: Defines the ratio between the young generation and the old generation. NewRatio=2 means the young generation will be 1/3rd of the total heap, and the old generation will be 2/3rds.
  • Why it matters: Most objects die young. Allocating a sufficiently large young generation can significantly reduce the frequency of full (old generation) garbage collections, which are typically longer.
  • How to use: java -XX:NewRatio=2 YourApp (Note: This flag is more relevant for older GCs like ParallelGC or CMS. G1 manages its young/old regions dynamically, but you can influence its behavior indirectly via other parameters.)

4. -XX:+UseParallelGC

  • What it does: Selects the Parallel collector, also known as the Throughput collector. It uses multiple threads to perform garbage collection, maximizing application throughput at the expense of potentially longer pause times.
  • Why it matters: If your application can tolerate longer pauses but needs to maximize the amount of work done over time, ParallelGC might be a better choice than G1.
  • How to use: java -XX:+UseParallelGC YourApp

Heap Management

Controlling the heap size and its internal structure is fundamental.

5. -Xms512m -Xmx2048m

  • What it does: Sets the initial heap size (-Xms) and the maximum heap size (-Xmx).
  • Why it matters: Too small a heap leads to frequent GC. Too large a heap can lead to long GC pauses and wasted memory. Finding the sweet spot is critical. Setting -Xms equal to -Xmx can prevent heap resizing overhead.
  • How to use: java -Xms1024m -Xmx1024m YourApp

6. -XX:SurvivorRatio=8

  • What it does: Determines the ratio of eden space to survivor spaces within the young generation. SurvivorRatio=8 means for every 8 KB of eden space, there is 1 KB of survivor space.
  • Why it matters: Objects that survive a young GC collection are moved to a survivor space. A larger survivor space can help objects survive more collections before being promoted to the old generation.
  • How to use: java -XX:SurvivorRatio=8 YourApp (Again, more impactful for older GCs; G1’s region-based approach is more dynamic.)

JIT Compilation

The Just-In-Time (JIT) compiler translates bytecode into native code, significantly boosting performance.

7. -XX:TieredCompilation

  • What it does: Enables tiered compilation. The JVM starts by interpreting code, then uses a C1 compiler for quick compilation, and finally a C2 compiler for heavily used methods to produce highly optimized code.
  • Why it matters: This provides a faster startup time (due to C1) and better peak performance (due to C2) compared to a single-tier compiler. It’s the default in modern JVMs.
  • How to use: java -XX:+TieredCompilation YourApp (Typically enabled by default, but explicit inclusion can be useful for clarity or troubleshooting.)

8. -XX:CompileThreshold=10000

  • What it does: Sets the number of method invocations or back-edge branches before a method is considered for compilation by the JIT compiler.
  • Why it matters: A lower threshold means methods get compiled sooner, potentially improving performance faster but increasing JIT overhead. A higher threshold reduces JIT overhead but delays peak performance.
  • How to use: java -XX:CompileThreshold=10000 YourApp

Threading

JVM threading flags are less commonly tweaked but can be vital in high-concurrency scenarios.

9. -XX:ThreadStackSize=1024

  • What it does: Sets the stack size for each thread in kilobytes. The default is usually 1024 KB (1 MB) on Linux/macOS and 512 KB on Windows.
  • Why it matters: If you encounter StackOverflowError in deep recursive calls, increasing this might help. Conversely, if you have thousands of threads, decreasing it can save significant memory.
  • How to use: java -XX:ThreadStackSize=2048 YourApp

When you’re dealing with JVM performance, the -XX flags are your most direct interface with the runtime’s internal machinery. They allow you to tune the garbage collector’s aggressiveness, the heap’s memory allocation strategy, and the JIT compiler’s optimization levels. For instance, by setting -XX:MaxGCPauseMillis=50 with -XX:+UseG1GC, you’re telling the JVM that short pauses are more important than raw throughput, and G1 will adjust its collection cycles accordingly by perhaps collecting smaller sets of regions more frequently. Similarly, tuning -XX:NewRatio affects how quickly objects are promoted, impacting the frequency of costly old-gen collections.

The next logical step after optimizing GC and heap is often understanding JVM diagnostic tools like JMX, visualvm, or jcmd, which allow you to monitor the effects of these flags in real-time.

Want structured learning?

Take the full Jvm course →