JVM Garbage Collectors are essential for Java memory management. It automatically frees up unused memory to prevent memory leaks and improve performance. Java manages memory through the Java Virtual Machine using a process called garbage collection. Garbage collection automatically frees up memory by removing objects from the Java heap that are no longer needed. Garbage collectors use the Mark and Sweep algorithm to clear unused memory.
In this article, we will learn the types of JVM Garbage Collectors and their implementation details.
Threads in Garbage Collection
1. Controlling Garbage Collection Threads
To control the number of threads used by the garbage collector, we can use multi-threaded collectors like the Parallel Garbage Collector.
Implementation:
java -XX:+UseParallelGC -XX:ParallelGCThreads=NumberOfThreads -jar ApplicationJar.java
2. Limiting GC Pause Time
To limit the maximum pause time during garbage collection, we can use the MaxGCPauseMillis option:
Implementation:
java -XX:+UseParallelGC -XX:MaxGCPauseMillis=SecInMillisecond -jar ApplicationJar.java
Types of Garbage Collectors
1. Serial Garbage Collector
- Serial Garbage Collector is the simplest type of garbage collector.
- It uses a single thread to handle all garbage collection tasks.
- When garbage collection is triggered, it pauses all running application threads.
- Serial Garbage Collector is used for small applications or embedded systems where memory is limited.
Implementation: To enable Serial Garbage Collector, we can use the following argument:
java -XX:+UseSerialGC -jar ApplicationJar.java
2. Parallel Garbage Collector
- Parallel Garbage Collector is the default garbage collector in Java 8.
- It is also known as the throughput collector
- It uses multiple threads to perform garbage collection tasks.
- It is designed to maximize performance by making full use of available CPU resources.
- Parallel Garbage Collector is suitable for applications that need high performance and can tolerate some pauses, such as batch processing systems.
- Parallel Garbage Collector is better than the Serial Garbage Collector
Note: The main difference between serial Garbage Collector and Parallel Garbage Collector is that
- Serial Garbage Collector uses a single thread for garbage collection.
- Parallel Garbage Collector uses multiple threads to improve performance and reduce pause times.
- One problem with the parallel garbage collector is that it pauses the application during minor operations also.
- It is best suited for applications that can handle such pauses.
- If we are using JDK 8 then parallel garbage collector is the default garbage collector.
Implementation: If we are running on java 9 and want to use parallel garbage collector then we should use below command:
java -XX:+UseParallelGC -jar ApplicationJar.java
3. Concurrent Mark-Sweep Collector
- Concurrent Mark-Sweep Collector is designed to minimize pause times by doing most of its work while the application is still running.
- It uses multiple threads to mark and clean up unreachable objects.
- As we know, Serial garbage collector and Parallel garbage collector freeze the running threads of the application while performing the garbage collection. But CMS Garbage collector will perform freezing of running threads i.e. application pause in two cases only:
- While performing the garbage collection, If there is a change in heap memory in parallel.
- While marking the referenced objects in the old generation space.
- Concurrent Mark-Sweep Collector is used for applications that require low latency, such as web servers and interactive applications.
Note: The main difference between serial Garbage Collector and Parallel Garbage Collector is that
- Parallel Garbage Collector uses multiple threads but stops all application threads during garbage collection
- CMS Garbage Collector allows the application to keep running most of the time, reducing pause times.
Implementation: To enable CMS Garbage Collector, we can use the following argument:
java -XX:+UseParNewGC -jar ApplicationJar.java
4. G1 Garbage Collector
- G1 Garbage collector was introduced in JDK 7 and became the default garbage collector in Java 9.
- Designed for applications with large heap sizes (greater than 4GB).
- Divides the heap into multiple equal-sized regions (1MB to 32MB).
- G1 Garbage collector replaced the CMS collector due to better performance efficiency.
- Marks regions with active objects and prioritizes collection in regions with the most unused objects, hence the name "Garbage-First" (G1).
- Compacts free heap space after garbage collection, improving memory efficiency.
Implementation: To use the G1 Garbage Collector in Java versions less than 9, specify the following command when running your application:
java -XX:+UseG1GC -jar ApplicationJar.java
5. Z Garbage Collector:
- ZGC is a low-latency garbage collector introduced in Java 11.
- It is designed to handle large heaps with minimal pause times, typically in the range of milliseconds.
Implementation: To enable Z Garbage Collector, we can use the following argument:
java-XX:+UseZGC -jar ApplicationJar.java
6. Shenandoah Garbage Collector
- Shenandoah is another low-pause-time garbage collector introduced in Java 12.
- It aims to reduce pause times by performing garbage collection concurrently with application threads.
Implementation: To enable Shenandoah Garbage Collector, we can use the following argument:
java-XX:+UseShenandoahGC -jar ApplicationJar.java
Garbage Collection JVM Options
JVM Arguments
Here’s a table describing the arguments that can be used to instruct the JVM:
Option | Description |
|---|
-Xms<size> | Sets the initial heap size. |
|---|
-Xmx<size> | Sets the maximum heap size. |
|---|
-XX:MaxMetaspaceSize=<size> | Sets the maximum metaspace size. |
|---|
-XX:+HeapDumpOnOutOfMemoryError | Generates a heap dump when an OutOfMemoryError occurs. |
|---|
-XX:HeapDumpPath=<path> | Specifies the path to save the heap dump file. |
|---|
-XX:+PrintGCDetails | Prints detailed garbage collection information to the console. |
|---|
-XX:+UseG1GC | Enables the G1 Garbage Collector (default for most modern JVMs) |
|---|
-XX:+UseContainerSupport | Optimizes JVM behavior in containerized environments. |
|---|
Garbage Collector Options
Here's a table describing the available garbage collections algorithms and optimization options in the JVM.
Option | Description |
|---|
-XX:+UseSerialGC | Enables the Serial Garbage Collector |
|---|
-XX:+UseParallelGC | Enables the Parallel Garbage Collector |
|---|
-XX:+UseConcMarkSweepGC | Enables the CMS Garbage Collector |
|---|
-XX:ParallelCMSThreads=<n> | Sets the number of threads to use |
|---|
-XX:+UseG1GC | Enables the G1 Garbage Collector |
|---|
-XX:+UseZGC | Enables the Z Garbage Collector |
|---|
-XX:+UseShenandoahGC | Enables the Shenandoah Garbage Collector |
|---|
-XX:ParallelGCThreads=<n> | Sets the number of threads for Parallel and G1 Garbage Collectors. |
|---|
-XX:G1HeapRegionSize=<size> | Sets the size of regions for G1 Garbage Collector. |
|---|