To improve Java application performance, adjust JVM arguments starting with heap size using -Xms and -Xmx to avoid memory issues and resizing overhead, then choose the right garbage collector like G1GC for low latency or Parallel GC for throughput, next tune GC settings such as -XX:MaxGCPauseMillis and monitor GC behavior, optionally use advanced flags like -XX: UseStringDeduplication, and always rely on monitoring tools to guide adjustments.

When you're trying to get better performance out of a Java application, one of the most direct ways is adjusting the JVM arguments. These settings control how the Java Virtual Machine manages memory, garbage collection, and other runtime behaviors that directly affect your app's speed and stability.

Set Initial and Maximum Heap Size (-Xms, -Xmx)

The two most common options you’ll use are -Xms and -Xmx.

• -Xms sets the initial heap size when the JVM starts.
• -Xmx defines the maximum heap size the JVM can use.

If these values are too low, your application may run into OutOfMemoryError. If they’re too high, you might be reserving more memory than needed, which could impact other applications or services running on the same machine.

A good starting point:

• Set both -Xms and -Xmx to the same value to avoid resizing the heap at runtime, which can cause performance hiccups.
• For example: -Xms2g -Xmx2g gives your app 2 GB of heap from start to finish.

Don’t guess — monitor actual usage using tools like VisualVM, JConsole, or GC logs to fine-tune these values based on real behavior.

Choose the Right Garbage Collector

Java has several garbage collectors (GC), each with different performance characteristics. Choosing the right one depends on your application’s needs:

• Throughput-focused apps (like batch jobs) often benefit from the Parallel GC (-XX: UseParallelGC).
• Low-latency apps (like web services) might prefer G1GC (-XX: UseG1GC) or even ZGC/Shenandoah if you're using newer JDKs.
• Avoid Serial GC unless you're on a very old system or have minimal resources.

Garbage collection pauses can seriously hurt performance, especially under load. Monitoring GC pause times and frequency helps determine whether switching collectors would help.

Some tips:

• G1GC works well for heaps larger than 4GB and aims to balance throughput and latency.
• If you see long GC pauses, it might not be the heap size alone — the collector choice matters too.

Tune Garbage Collection Settings

Once you've picked a garbage collector, you can further tune its behavior.

For example, with G1GC, you can set:

• -XX:MaxGCPauseMillis=200 — tells the JVM to try to keep GC pauses under 200 milliseconds.
• -XX:G1HeapRegionSize=4M — controls the internal region size (not always necessary to change).

Other general GC-related flags:

• -XX: DisableExplicitGC disables calls to System.gc() — useful if some libraries trigger full GCs unnecessarily.
• -XX: PrintGCDetails -XX: PrintGCDateStamps logs GC activity so you can analyze what’s happening in production.

Also, don’t ignore the Metaspace, which replaced PermGen in Java 8 . You can limit it with -XX:MaxMetaspaceSize to prevent memory leaks from consuming all available memory.

Optional but Useful Flags

Here are a few more flags that aren’t strictly performance-related but can help indirectly:

• -server — enables server-specific optimizations (on by default in most 64-bit JVMs).
• -XX: AggressiveOpts — turns on advanced performance optimizations where supported.
• -XX: UseLargePages — allows using large memory pages, which can improve performance on systems that support them.
• -XX: UseStringDeduplication (with G1GC) — reduces memory usage by deduplicating duplicate strings.

You won’t need all of these in every case, but knowing they exist lets you explore deeper tuning when basic settings aren't enough.

That's basically how you approach JVM performance tuning through command-line arguments — start with heap size, choose the right GC, tweak its settings, and optionally apply advanced flags where appropriate. It’s not overly complex, but it’s easy to overlook key details without monitoring and testing.

The above is the detailed content of What are JVM arguments for performance tuning (e.g., -Xms, -Xmx, -XX:)?. For more information, please follow other related articles on the PHP Chinese website!