Mastering JVM Argument Prefixes: Boost Java Performance & Debugging

1. Overview

Java Virtual Machine (JVM) is a powerful engine that runs compiled .class files, manages memory, and improves performance through JIT compilation and garbage collection.

The JVM is highly flexible; by using the right arguments we can tune its behavior for performance, troubleshooting, and experimental features. This tutorial explores the different argument prefixes available for configuring the JVM.

2. What are JVM arguments?

JVM arguments are special command‑line options that change the JVM’s behavior. They control memory settings, performance tuning, debugging, monitoring, garbage‑collection configuration, and experimental features.

We can specify them when starting the JVM, for example:

java -Xmx512m -Denv=prod -verbose:gc -XX:+UseG1GC -jar App.jar

Each prefix indicates the type of configuration being passed. -Xmx512m – sets maximum heap size to 512 MB (non‑standard option). -Denv=prod – defines a system property named env with value prod (system property). -verbose:gc – enables garbage‑collection logging (standard option). -XX:+UseG1GC – tells the JVM to use the G1 garbage collector (advanced option).

3. Different JVM argument prefixes

3.1. System properties ( -D )

System properties configure JVM‑specific parameters such as file encoding, user directory, JVM version, etc.

Define a key‑value pair with -D: java -Denv=prod -jar App.jar The -D stands for “Define”.

3.2. Standard options ( - )

Standard options are documented settings supported by all JVM implementations, used to control basic behavior.

Examples: java -classpath … and java -version which prints the JVM version.

Running java without arguments shows the full list of standard options.

Usage: java [options] <mainclass> [args...] ...

3.3. Non‑standard options ( -X )

The -X prefix accesses non‑standard JVM features, often related to memory and debugging. These options may differ between JVM implementations.

List all non‑standard options: java -X Sample output (varies by JVM):

-Xbatch            disable background compilation
-Xbootclasspath/a:<…>
-Xcheck:jni        perform additional checks for JNI functions
-…

3.4. Advanced options ( -XX )

Advanced options enable low‑level or experimental features and start with -XX. They are either boolean (enable/disable) or value options.

Some options are stable across versions, while others may be deprecated or removed.

Example of using advanced options to tune garbage collection:

java -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -jar App.jar

This enables G1 GC and requests pause times below 200 ms.

4. JVM execution modes

The JVM can run in different execution modes that control JIT compilation.

We use a benchmark that fills a HashMap with one million entries and then reads them back.

public class Benchmark {
    private static final int NUM_ENTRIES = 1_000_000;
    public static void main(String[] args) {
        Benchmark benchmark = new Benchmark();
        benchmark.run();
    }
    public void run() {
        HashMap<Integer, String> map = new HashMap<>();
        long startPut = System.nanoTime();
        for (int i = 0; i < NUM_ENTRIES; i++) {
            map.put(i, "Value" + i);
        }
        long endPut = System.nanoTime();
        System.out.println("Time to put: " + (endPut - startPut) / 1_000_000 + " ms");
        long startGet = System.nanoTime();
        for (int i = 0; i < NUM_ENTRIES; i++) {
            String value = map.get(i);
            if (value == null) {
                System.err.println("Missing key: " + i);
            }
        }
        long endGet = System.nanoTime();
        System.out.println("Time to get: " + (endGet - startGet) / 1_000_000 + " ms");
    }
}

4.1. -Xint – interpreted‑only mode

The -Xint flag forces the JVM to interpret all bytecode, disabling JIT compilation, which dramatically slows execution. It is useful for debugging JIT‑related issues.

java -server -showversion -Xint Benchmark
... Time to put: 1532 ms
... Time to get: 261 ms

4.2. -Xcomp – compile‑all mode

The -Xcomp flag forces compilation of all methods on first use, avoiding the interpreter but increasing startup time.

java -server -showversion -Xcomp Benchmark
... Time to put: 1167 ms
... Time to get: 10 ms

4.3. -Xmixed – default mixed mode

Mixed mode starts with interpretation and JIT‑compiles hot methods, balancing startup time and runtime performance.

java -server -showversion Benchmark
... Time to put: 75 ms
... Time to get: 12 ms

4.4. -Xverify – verification control

Bytecode verification ensures code safety before execution. -Xverify:all (default) verifies all classes; -Xverify:none skips verification, improving startup at the cost of security.

java -Xverify:none -cp app.jar com.baeldung.Main

5. Conclusion

This tutorial explored the various JVM argument prefixes and execution modes. The mixed mode offers the most efficient and stable behavior for typical applications. Choosing the right JVM arguments can improve performance, stability, and debugging capabilities, but the decision depends on application complexity and performance requirements.