JVM Parameters | Java Performance Optimization

Introduction

JVM parameters are used to configure the Java Virtual Machine (JVM), which is responsible for executing Java bytecode. By properly configuring the JVM parameters, we can improve the performance of Java applications. In this lab, we will learn how to set some commonly used JVM parameters to optimize the performance of Java applications.

Setting Heap Memory

The heap memory is the runtime data area in which Java objects are allocated. We can set the heap memory size with the -Xmx and -Xms parameters.

-Xmx<heap size>[unit]: sets the maximum heap size.
-Xms<heap size>[unit]: sets the initial heap size.

For example, to set the minimum heap size to 512MB and the maximum heap size to 1GB, we can use the following command:

java -Xms512m -Xmx1g MyApp

Choosing Garbage Collectors

Garbage collection is the process of freeing memory occupied by objects that are no longer being used by the Java application. The choice of garbage collector can have a significant impact on the performance of the application. JVM provides several garbage collectors, each with their own strengths and weaknesses.

-XX:+UseSerialGC: enables the serial garbage collector, which uses a single thread for garbage collection.
-XX:+UseParallelGC: enables the parallel garbage collector, which uses multiple threads for garbage collection.
-XX:+UseParNewGC: enables the concurrent-mark-sweep (CMS) garbage collector, which uses multiple threads to perform concurrent garbage collection.
-XX:+UseG1GC: enables the Garbage-first (G1) garbage collector, which is designed to provide consistent pause times and high throughput.

For example, to enable the parallel garbage collector, we can use the following command:

java -XX:+UseParallelGC MyApp

Logging Garbage Collection Activities

Garbage collection logging allows us to monitor the performance of the garbage collector and tune the garbage collector parameters based on the application's requirements. We can use the following parameters to enable garbage collection logging:

-XX:+UseGCLogFileRotation: enables log rotation for garbage collection logs.
-XX:NumberOfGCLogFiles=<number of log files>: limits the number of log files for garbage collection logs.
-XX:GCLogFileSize=<file size><unit>: specifies the size limit for garbage collection logs.
-Xloggc:[path to gc.log file]: specifies the path for garbage collection logs.

For example, to enable garbage collection logging and set the log file path to /path/to/gc.log, we can use the following command:

java -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=10M -Xloggc:/path/to/gc.log MyApp

Out Of Memory Error Handling

When the JVM runs out of memory, it throws an Out Of Memory Error. We can use the following JVM parameters to handle this error:

-XX:+HeapDumpOnOutOfMemoryError: when the Out Of Memory Error occurs, the JVM will write a heap dump to disk.
-XX:HeapDumpPath=<path to heap dump file>: specifies the path for the heap dump file.
-XX:OnOutOfMemoryError=<command>: when the Out Of Memory Error occurs, the JVM will execute the specified command.
-XX:+UseGCOverheadLimit: the JVM uses this option to set a limit on the amount of time spent in garbage collection.

For example, to configure the JVM to write a heap dump to the file /path/to/heapdump.hprof when the Out Of Memory Error occurs, we can use the following command:

java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/heapdump.hprof MyApp

Using 64-bit JVM

We can use the -d parameter to select the 32-bit or 64-bit JVM. For example, to use the 64-bit JVM, we can use the following command:

java -d64 MyApp

Compiling and Running Java Application with JVM Parameters

Let's use the HelloWorld.java program to compile and run the Java application with the JVM parameters that we learned in the previous steps.

cd ~/project
touch HelloWorld.java
touch HelloWorld.java

Enter the following code:

class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Save the file and exit. Now, let's compile and run the code with the -Xmx parameter:

javac HelloWorld.java
java -Xmx512m HelloWorld

This sets the maximum heap size to 512MB. We should see the output:

Hello, World!

Compiling and Running Java Application with Garbage Collectors

Now, let's compile and run the Java application with the parallel garbage collector:

java -XX:+UseParallelGC HelloWorld

We should see the output:

Hello, World!

Compiling and Running Java Application with Garbage Collection Logging

Now, let's compile and run the Java application with garbage collection logging enabled:

java -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=10M -Xloggc:/path/to/gc.log HelloWorld

This sets the log file path to /path/to/gc.log.

Compiling and Running Java Application with Other Frequently Used Parameters

Now, let's compile and run the Java application with the -XX:+UseStringDeduplication and -XX:MaxHeapFreeRatio parameters:

java -XX:+UseStringDeduplication -XX:MaxHeapFreeRatio=70 HelloWorld

This enables string deduplication and sets the maximum ratio of free heap space after garbage collection to 70%.

Summary

In this lab, we learned how to set various JVM parameters to optimize the performance of Java applications. We learned how to set heap memory size, choose garbage collectors, enable garbage collection logging, handle Out Of Memory Errors, use 64-bit JVM, and set some other frequently used parameters. We also learned how to compile and run a Java application with JVM parameters.

Optimizing Java Application Performance