In this article, we will explore Garbage Collection in Java. Let’s get started.
What is Garbage Collection in Java ?
Garbage collection in Java is a crucial automated memory management process that helps developers manage memory allocation and deallocation for objects created during the execution of a Java program. In simple terms, it’s a mechanism that automatically identifies and removes objects in memory that are no longer in use, freeing up memory resources for new objects.
When does an Object becomes Eligible for Garbage Collection in Java?
- An object which is not reachable from any live threads or by any static references.
- Cyclic dependencies are not counted as reference so if object A has reference of object B and object B has reference of Object A and they don’t have any other live reference then both Objects A and B will be eligible for Garbage collection.
- Object’s GC eligibility also depends on the type of reference it has.
| Reference | Garbage Collection |
|---|---|
| Strong Reference | Not eligible for garbage collection |
| Soft Reference | Garbage collection possible but will be done as a last option |
| Weak Reference | Eligible for Garbage Collection |
| Phantom Reference | Eligible for Garbage Collection |
Please visit Heap to know about Heap sub areas and Minor GC.
Three Phases of Garbage Collection in Java
Garbage collection, a fundamental process in memory management, involves three crucial steps that ensure efficient memory utilization and the removal of unused objects. Let’s break down these three steps:
1. Mark:
Imagine your computer’s memory as a vast library filled with books (objects). Some books are being actively read (used), while others are gathering dust (unused). The marking phase is like a diligent librarian going through the library, placing bookmarks (marks) in all the books that are still being read (reachable).
In the context of garbage collection, this step identifies and marks all the objects that are still in use by the program. It usually starts from a set of root objects (like the main function in your application) and traverses through the object references to determine which objects are reachable.
2. Sweep/Delete:
Now, think of your library again. You’ve marked the books that are still in use, but what about those without bookmarks? These are the objects that are no longer needed (unreachable). The sweeping phase involves cleaning up the library by removing all the books that lack bookmarks.
In garbage collection, this step deals with reclaiming memory occupied by unreachable objects. The collector sweeps through the heap (memory space allocated for your program) and removes objects that are no longer accessible. This process frees up memory for future use.
3. Compact:
After cleaning up the library, you notice that some shelves have gaps between books, making the library look disorganized. To optimize space, you decide to rearrange the books, moving them closer together. This compacting step ensures that the library’s layout is efficient, and there’s no wasted space.
In memory management, compaction involves rearranging the memory to reduce fragmentation. Fragmentation occurs when memory is allocated and deallocated over time, leading to small gaps between objects. Compaction helps in defragmenting the memory, making it more contiguous and efficient for object allocation.
These three steps—mark, sweep/delete, and compact—constitute the core of garbage collection in programming languages. They ensure that your program uses memory effectively by identifying and removing unused objects, ultimately contributing to better performance and memory optimization.
Types of Garbage Collectors in Java
In Java, there are several types of garbage collectors:
- Serial Garbage Collector (Serial GC): It uses a single thread for garbage collection and is suitable for single-threaded applications or applications with small data sets.
- Parallel Garbage Collector (Parallel GC): Also known as the throughput collector, it uses multiple threads to perform garbage collection in the young generation. It is designed for applications where throughput is a priority.
- Concurrent Mark-Sweep (CMS) Collector: It minimizes application pause times by doing most of the work concurrently with the application threads. It’s suitable for applications that prioritize low-latency performance.
- G1 Garbage Collector (Garbage-First GC): G1 divides the heap into regions and performs garbage collection with an emphasis on low pause times and high throughput. It’s a good choice for applications with large heaps and strict latency requirements.
- Z Garbage Collector (ZGC): Introduced in Java 11, ZGC is designed for applications that require low-latency and can handle very large heaps. It aims to keep pause times consistently low, even for large heaps.
Read More : JVM Garbage Collector Types
Conclusion: Garbage Collection in Java
Understanding garbage collection in Java is essential for efficient memory management in your applications. It’s a process that automatically identifies and removes unused objects, optimizing memory resources. Objects become eligible for garbage collection when they’re no longer reachable from live threads or static references.
The three phases of garbage collection—mark, sweep/delete, and compact—work together to ensure your program utilizes memory effectively. Marking identifies live objects, sweeping deletes the unreachable ones, and compaction optimizes memory layout.
Java offers various types of garbage collectors, each catering to different application needs. Whether it’s Serial GC for single-threaded applications, Parallel GC for high throughput, CMS for low-latency performance, G1 for large heaps, or ZGC for low-latency with large heaps, choosing the right garbage collector is crucial for your Java applications.
Related Article: Garbage Collection Optimization in Java: Balancing Throughput, Latency, and Footprint