DeployU
Interviews / Backend Engineering / How does garbage collection work in Java?

Questions

Your Java service is slow. How do you debug a JVM performance issue?
Q C
How does garbage collection work in Java?
Q C
What is the difference between `==` and `.equals()` in Java?
Q C
What are annotations and how do you use them in Java?
Q C
What is the difference between `final`, `finally`, and `finalize` in Java?
Q C
What is the difference between `String`, `StringBuilder`, and `StringBuffer` in Java?
Q C
What is the difference between an `interface` and an `abstract class` in Java?
Q C
What is the difference between `HashMap`, `TreeMap`, and `LinkedHashMap` in Java?
Q C
How do you handle concurrency in Java?
Q C
What are generics and why are they useful in Java?
Q C
What is the difference between a `checked` and an `unchecked` exception in Java?
Q C
How do you use the `Stream` API to process a collection of data?
Q C

How does garbage collection work in Java?

conceptual JVM Interactive Quiz Code Examples

The Scenario

You are a backend engineer at a social media company. You are debugging a memory leak in a Java service. The service’s memory usage is constantly increasing, and it eventually crashes with an OutOfMemoryError.

You need to understand how garbage collection works in Java so that you can find the source of the leak and fix it.

The Challenge

Explain how garbage collection works in Java. What is the role of the garbage collector, and how does it decide when to free up memory?

Wrong Approach

A junior engineer might not be aware of the details of garbage collection in Java. They might think that memory is managed automatically and that they don't need to worry about it.

Right Approach

A senior engineer would be able to provide a detailed explanation of how garbage collection works in Java. They would be able to explain the role of the garbage collector and the different garbage collection algorithms that are used. They would also have a clear plan for how to debug a memory leak.

Step 1: Understand the Basics of Garbage Collection

Garbage collection is the process of automatically freeing up memory that is no longer being used by an application. In Java, the garbage collector runs in the background and is responsible for managing the memory of the JVM.

Step 2: The Mark and Sweep Algorithm

The most common garbage collection algorithm is the mark and sweep algorithm. It works as follows:

  1. Mark: The garbage collector starts at the root objects (e.g., the objects on the call stack) and traverses the object graph, marking all the objects that are reachable.
  2. Sweep: The garbage collector then sweeps through the heap and frees up all the objects that are not marked.

Step 3: Generational Garbage Collection

Modern JVMs use a generational garbage collection algorithm, which is an optimization of the mark and sweep algorithm. It works by dividing the heap into two generations: the young generation and the old generation.

GenerationDescription
Young GenerationNew objects are allocated in the young generation. Most objects die young, so the young generation is garbage collected frequently.
Old GenerationObjects that survive a few garbage collections in the young generation are promoted to the old generation. The old generation is garbage collected less frequently.

Step 4: Different Garbage Collectors

There are several different garbage collectors available in the JVM, each with its own trade-offs:

Garbage CollectorDescription
Serial GCA single-threaded garbage collector that is suitable for small applications.
Parallel GCA multi-threaded garbage collector that is suitable for applications with a large heap.
CMS GCA concurrent garbage collector that is designed to minimize the length of the garbage collection pauses.
G1 GCA concurrent, parallel, and generational garbage collector that is the default garbage collector in modern versions of the JVM.

Practice Question

You have an application that is sensitive to long garbage collection pauses. Which garbage collector would be the most appropriate?