1. Overview
The Java Virtual Machine (JVM) is a powerful engine that powers Java applications. It is highly customizable and provides basic configuration through standard options, general performance tuning through non-standard options, and precise control through advanced options.
Advanced options allow developers to fine-tune performance, diagnose issues, and experiment with cutting-edge features.
In this tutorial, we’ll explore the most well-known advanced JVM options and how to use them, allowing us more fine-grained control over JVM behavior.
2. Classification of JVM Options
JVM arguments can be classified into three main categories:
- Standard Options (-version, -help)
- Non-Standard Options (-X: options)
- Advanced Options (-XX: options)
3. Understanding Advanced JVM Options
Advanced options go beyond basic configuration to set lower-level properties of the JVM. These options allow us to adjust performance-critical parameters, such as garbage collection, memory management, and runtime diagnostics.
Some of these advanced options are also among the most important JVM parameters that are commonly used. Understanding how to set these JVM options in IntelliJ can be beneficial for tuning the JVM for development and debugging.
However, as they provide fine-tuning for specific application scenarios, we must use them cautiously. Excessive customization without a clear understanding of application behavior can result in poor performance, crashes, or unexpected behavior.
Additionally, advanced JVM options are not guaranteed to be supported by all JVM implementations and are subject to change. Therefore, since these options evolve with JVM updates, some may become deprecated or behave differently in the newer versions.
For example, this happened with the Java concurrent mark and sweep garbage collection algorithm, which was deprecated in Java 9 and removed in Java 14. By monitoring the documentation, we can stay informed before any changes occur.
Let’s now explore various advanced JVM options through different categories.
4. Garbage Collection Tuning
Garbage collection is essential for memory management but can introduce pauses that affect performance. Advanced options offer control over garbage collection behavior, ensuring smoother application runtime.
Since Java 9, the default has been the garbage-first garbage collector (G1), designed to balance throughput and latency.
To overcome G1’s latency limitations, JDK12 introduced Shenandoah GC, which can be enabled with the
-XX:+UseShenandoahGC option. Shenandoah’s availability depends on the JDK vendor and release.
Other implementations can be used based on specialized workloads. The Epsilon garbage collector is also great for performance tuning to check whether garbage collection affects our program’s performance.
The topics referenced earlier explored various useful advanced JVM options for garbage collection.
5. Memory Management
As we discussed above, garbage collection is an essential part of memory management, but it’s only part of the larger memory management ecosystem in the JVM.
To achieve optimal performance, it is equally vital to configure memory allocation, manage heap sizes, and understand how off-heap memory works, especially for memory-intensive applications or systems with specific performance requirements.
Now, let’s review some of the advanced JVM options related to memory management:
- -XX:InitialHeapSize and -XX:MaxHeapSize – These options define the initial and maximum heap size in bytes
- -XX:MetaspaceSize and -XX:MaxMetaspaceSize – These options define the initial and maximum size of the metaspace area
- -XX:InitialRAMPercentage and -XX:MaxRAMPercentage – These options define the initial and maximum heap size as percentages of the system’s available memory. These settings allow the JVM to scale its memory usage dynamically, offering better adaptability
- -XX:MinHeapFreeRatio and -XX:MaxHeapFreeRatio – These options define the minimum and maximum percentage of how much free space is maintained in the heap after a GC cycle
- -XX:+AlwaysPreTouch – Reduces latency by pre-touching the Java heap during JVM initialization. Every heap page is, therefore, initialized on JVM startup rather than incrementally during application execution
- -XX:MaxDirectMemorySize – Defines the amount of memory that can be reserved for Direct Byte Buffers
- -XX:CompressedClassSpaceSize – Defines the maximum memory allocated for storing class metadata in the metaspace when using compressed class pointers (-XX:-UseCompressedClassPointers)
6. Just-in-Time Compilation
Just-in-Time (JIT) compilation is a crucial JVM component that compiles bytecode to native machine code at run time, improving the performance of Java applications. The JIT compiler is enabled by default, and disabling it is not advisable except for investigating JIT compilation issues.
Let’s review the advanced JVM options for configuring and tuning JIT compilation:
- -XX:CICompilerCount – Defines the number of compiler threads used for JIT compilation. The default value is proportional to the number of available CPUs and memory
- -XX:ReservedCodeCacheSize – Defines the maximum size of the memory area allocated for storing JIT-compiled native code
- -XX:CompileThreshold – Defines the number of method invocations before the method is first compiled
- -XX:MaxInlineSize – Defines the maximum allowable size (in bytes) for methods that the JIT compiler can inline
7. Diagnostics and Debugging
Diagnostics and debugging are crucial for identifying and addressing issues in Java applications, such as performance bottlenecks, memory leaks, and unexpected behavior.
Let’s review the advanced JVM options related to diagnostics and debugging that can help us gain deeper insights into our application’s behavior and performance:
- -XX:+HeapDumpOnOutOfMemoryError – Generates a heap dump when an OutOfMemoryError occurs
- -XX:HeapDumpPath – Defines the file path for saving the heap dump
- -XX:+PrintCompilation – Logs JIT compilation
- -XX:+LogCompilation – Writes detailed JIT compilation logs to a file
- -XX:+UnlockDiagnosticVMOptions – Unlocks diagnostic JVM options that are not available by default
- -XX:+ExitOnOutOfMemoryError – Forces the JVM to exit immediately upon encountering an OutOfMemoryError
- -XX:+CrashOnOutOfMemoryError – Forces the JVM to generate a core dump and crash upon an OutOfMemoryError
- -XX:ErrorFile – Defines the file path where error data will be saved in the event of an unrecoverable error
- -XX:NativeMemoryTracking – Defines the mode (off/summary/detail) for tracking JVM native memory usage
- -XX:+PrintNMTStatistics – Enables printing of collected native memory tracking data at JVM exit. It can only be used when native memory tracking is enabled (-XX:NativeMemoryTracking)
The advanced JVM options -XX:+PrintGC and -XX:+PrintGCDetails for logging GC information have been deprecated since Java 9 and should be replaced with -Xlog, the unified logging option.
8. Ergonomics
We’ve explored many powerful advanced JVM options, which may make configuring and tuning the JVM to meet our specific requirements feel overwhelming. JVM provides a solution through ergonomics, automatically tuning its behavior based on the underlying hardware and runtime conditions, enhancing application performance.
Let’s list all ergonomic defaults for our environment:
java -XX:+PrintFlagsFinal -versionHowever, although ergonomics aims to set reasonable defaults, they may not always match our application’s needs.
9. Conclusion
In this article, we comprehensively explored advanced JVM options, combining insights from the discussions referenced throughout and the analysis presented.
