An Overview of Java Garbage Collectors

Transcript

Hi friends! Today, we are talking about Garbage Collectors in Java.

Choosing a right GC implementation may help you boost the app performance. HotSpot JVM offers seven collectors for various performance requirements. So, let’s look at all of them!

A couple of words about Java Memory Model

Young generation, old generation

Serial GC 

Serial GC is the simplest and the oldest collector in Java. It works in one thread and freezes all app threads while performing collection. It is good for single-threaded client-side applications that don’t need extra small pauses. But there’s a catch: if you limit your application to 2 GB RAM and less than 2 processors, SerialGC will be used automatically, even if you explicitly specify another collector! So be careful with that.

Parallel GC

Parallel GC is also called a throughput collector. It freezes all application threads, but works in multiple threads during the collection. By default, it works in multiple threads when it collects the young generation and the old generation. You can set the number of worker threads, pause time, and the time application spends on the collection.

Concurrent Mark Sweep GC

Concurrent Mark Sweep GC is designed for shorter pauses and uses multiple threads to perform the collection. But it is suitable for applications that can afford to share processor resources with the collector while the application is running. This collector was deprecated in Java 9 and removed in Java 14. 

G1 GC

G1 GC was designed to replace CMS GC. It is now a default garbage collector in Java. G1 GC tries to provide good balance between latency and throughput and is a very good fit for applications running in multiprocessor environments with a large heap of 10 gigabytes and more.

G1 means Garbage First. Just like other collectors, it works with young and old generations, but it splits the heap into multiple equal-sized regions. First, it performs global marking concurrently with the application and determines which objects are reachable. Then, it reclaims space in regions that are mostly filled with garbage, and so frees more memory, this is why it is called garbage first. G1 GC reclaims space using evacuation: it copies and compacts live objects from one or several regions into new regions.

Z GC

Z GC was first introduced in Java 11. It is a scalable low-latency collector, and it is great for latency-sensitive applications and applications with a very large heap of terabytes.

Z GC performs the expensive work concurrently and doesn’t stop the application threads for more than 10 ms. It requires minimal configuration, in most cases, just set the right heap size and you are good to go.

In Java 21, it became generational by default. It means that it maintains separate generations for young and old objects and collects young objects more frequently, which improves heap memory overhead and garbage collection CPU overhead.

Shenandoah GC

Shenandoah GC is also a low-latency collector introduced in Java 12. It performs most of its work concurrently with the app, including the concurrent compaction, so the pause times are not directly proportional to the heap size. Like Z GC, it is suitable for latency-sensitive applications and applications with a very large heap of terabytes. Oracle Java doesn’t ship Shenandoah, but this GC comes with major OpenJDK distributions including Liberica JDK.

Epsilon GC

Epsilon GC is a very interesting garbage collector. It doesn’t perform any garbage collection and only allocates memory. Why would you use a garbage collector that doesn’t collect any garbage? Well, it has a purpose. First, you can use it for performance testing to see how fast the program would run without any garbage collection and if there are performance bottlenecks not induced by the collector.

Also, you can use it with applications that almost don’t produce garbage. Or if the app is short-lived and doesn’t have time to leave garbage. Then the program may run faster without garbage collection cycles.

Another interesting feature of Epsilon GC is that it will remain an experimental feature forever so that you don’t accidentally use it in production. So, to use Epsilon GC, you need to explicitly enable experimental features.