Garbage Collection in Java: A Comprehensive Guide

Ever wondered how Java manages memory so efficiently, allowing developers to focus on writing great code? The secret lies in the sophisticated Garbage Collection process. Understanding Garbage Collection in Java is crucial for optimising performance and ensuring the smooth operation of your applications.

Java's Automated Memory Management is a game-changer for developers, preventing memory leaks and enhancing application reliability. By mastering Garbage Collection in Java, you can write more efficient, high-performance code. Let's explore the world of Garbage Collection and discover how it keeps your applications running smoothly! 

Table of Contents

1) Understanding Garbage Collection in Java

2) How Does Java Garbage Collection Work? 

3) What are the Different Types of Garbage Collectors? 

4) When is an Object Eligible for Garbage Collection?

5) Java Garbage Collection Methods

6) Advantages of Garbage Collection in Java

7) What Events Trigger Java Garbage Collection?

8) What is the Difference Between Garbage Collection and Memory Leak?

9) Conclusion

Understanding Garbage Collection in Java

Garbage Collection is a crucial aspect of Java's automatic memory management system. In other languages like C and C++, programmers must manually create and destroy objects. However, Java automates this process to prevent memory-related issues.

In C and C++, overlooking object destruction can lead to "memory leaks." These leaks cause a continuous growth in memory usage, eventually leading to "OutOfMemoryErrors" and program termination.

In these languages, developers use functions like "free()" in C and "delete()" in C++ for Garbage Collection. However, in Java, this process occurs automatically during a program's execution, eliminating the need for manual memory deallocation and ensuring memory leaks are avoided.

Java Garbage Collection functions when Java programs run on the Java Virtual Machine (JVM). Objects created during a program's lifetime reside in an allocated portion of memory known as the heap.

As the program progresses, new objects are created, and others become obsolete. These objects fall into two categories within the heap:

a) Live objects: Actively in use and referenced elsewhere in the program.

b) Dead objects: No longer needed or referenced.

The Garbage Collector identifies and removes these dead objects, releasing memory for efficient use. This automated process allows Java Developers to focus on writing code rather than managing memory, contributing to Java's reliability and ease of use.
 

 

How Does Java Garbage Collection Work?

As a programmer, you are responsible for both an object's creation and destruction. You are expected to remove an object, similar to how you declare them in most programs. Failing to do so would often result in the message “OutOfMemoryErrors” being thrown by your compiler. In such a scenario, Java’s GC feature shines brightly by automating object destruction.  

Java’s GC feature is a blessing to programmers, allowing you to focus on your main goal instead. Java runs its program by converting them into Bytecodes, which are then interpreted by Java Virtual Machine. Any object created is stored in a heap memory, which JVM dedicates to storing data.    

GC ensures this heap has free space by deleting any unnecessary object; hence, they are called “Garbage” in the program. An object that is categorised as so if it is considered an “unreachable object”. Any present thread within a program cannot access this object. But you must be wondering how JVM can categorise an object as unreachable. It does so while considering certain factors, such as the generation of objects in the collection process. 

Learn to build applications from scratch with our Introduction to Java EE Training – Sign up today!

Object Generations in Java
 

  

Java GC follows a generational strategy, allowing it to categorise objects by age. Most objects in a program have a relatively short life span, allowing them to get categorised as Garbage objects. The generation of Java objects in the Garbage Collection is as follows. 

1) The Young Generation objects: A freshly created object starts by being categorised into the Young Generation. This generation is divided into three parts and two categories: one Eden space and two survivor spaces. A newly declared object is stored in Eden space. When an object has survived Garbage Collection for the first time, it gets moved to the survivor space. Collection in the Young Generation is also called a minor Garbage Collection event. 

2) The Old Generation objects: When an object has lived long enough in the Young Generation, GC will move it into the Old Generation category. Collection in Old Generation is referred to as a major Garbage Collection event. 

3) The Permanent Generation objects: All forms of metadata, such as methods and classes, are stored in the Permanent Generation. JVM collects any class or method with no further use from Permanent Generation. Alternatively, when JVM performs a full Garbage Collection, all unused objects are collected irrelevant of their generation.

Important Concepts Related to Garbage Collection in Java

1) Unreachable Objects

An object is considered unreachable if no references point to it. Additionally, objects that are part of an "island of isolation" are also deemed unreachable.
 

Integer i = new Integer(4);  // The new Integer object is reachable via the reference in 'i' i = null;  // The Integer object is no longer reachable.

 

2) Eligibility for Garbage Collection

An object becomes eligible for Garbage Collection (GC) when it is unreachable. In the example above, after i = null, the Integer object 4 in the heap is eligible for Garbage Collection.

What are the different types of Garbage Collectors?

Java provides a spectrum of Garbage Collectors, each meticulously designed to cater to distinct application demands. Let's take a look at some of these Garbage Collectors:

1) Serial Garbage Collector: As Java's default collector, it suits small to medium-sized applications with modest throughput requirements. It functions efficiently, minimising the occurrence of disruptive "stop the world" events. However, it may not be the ideal choice for applications with stringent performance demands. 

2) Parallel Garbage Collector: This collector is engineered for high-throughput applications, particularly those dealing with extensive memory heaps. Leveraging multiple CPU cores accelerates the Garbage Collection process. But there's a trade-off – it temporarily freezes application threads during Garbage Collection, which may not be acceptable for applications with stringent responsiveness requirements. 

3) Concurrent Mark Sweep (CMS) Collector: Ideal for applications that demand minimal pause times. It excels in scenarios with numerous live objects and strives to keep pauses short. However, its performance can degrade under heavy memory pressure, making it essential to monitor closely. 

4) G1 Garbage Collector: Tailored for large memory heaps, the G1 Garbage Collector adeptly manages a mix of short and long-lived objects. It uses multiple threads for concurrent heap scanning and compaction. G1 offers a balanced approach, aiming to minimise both pause times and overall Garbage Collection overhead. 

Selecting the right Garbage Collector depends on a thorough understanding of your application's specific needs. Furthermore, you can fine-tune collector settings to optimise performance, ensuring your Java application runs smoothly even under varying workloads.

When is an Object eligible for Garbage Collection?

An object in a programming language becomes eligible for Garbage Collection when it is no longer referenced by any part of the program. Automatic Garbage Collection is handled by the programming language's runtime environment to reclaim memory.

In most modern programming languages, this process is automatic. The runtime environment periodically scans the heap (the memory area used for dynamically allocated objects) to identify objects that are no longer reachable from any active object in the program. Once an object is identified as unreachable, it is marked as garbage, and its memory can be reclaimed.

The timing of when an object becomes eligible for Garbage Collection depends on the specific algorithm used by the runtime environment. Some algorithms are more aggressive and reclaim memory quickly, while others may delay Garbage Collection to optimise performance. Generally, programmers do not need to manually manage memory, as the runtime environment handles this automatically.

Become a Java expert with our Java Engineer Training – Sign up today

Java Garbage Collection methods 

GC in JVM works automatically and doesn’t require you to delete an object once its scope is finished manually. However, the conditions necessary to trigger GC can be triggered by a programmer, including invoking GC and qualifying objects. 

Dereferencing objects  

GC primarily targets objects for cleanup when they are dereferenced. There are certain methods to dereference an object within a Java program, and some common methods of dereferencing objects are as follows. 

1) Assign null value: This can be done by allotting a null value to a previously declared object. By setting the reference value of an object to null, you’ll dereference it. As the example below shows, using the null keyword as a reference value to your object myString has dereferenced it.
 

public class ObjectDemo { public static void main(String[] args) { // Create a new object of the String class String myString = new String("Hello World"); // Output the string before it is dereferenced System.out.println("Before dereferencing: " + myString); // Set the reference variable to null to dereference the object myString = null; // Output the string after it is dereferenced System.out.println("After dereferencing: " + myString); } }

Output: 

Before dereferencing: Hello World  
After dereferencing: null

2) Assign value to another object: This can be done by reassigning the value of an object to another object. This makes the previous object dereferenced, thus qualifying for the Garbage Collection process. 

Program: 
 

public class Main { public static void main(String[] args) { // create a new Person object Person person1 = new Person("John", 25); // assign the reference value of person1 to person2 Person person2 = person1; // assign null to person1, dereferencing the object it referred to person1 = null; // print the name of person2 (which still refers to the object) // and print person1 (which is null) System.out.println("Person 2 name: " + person2.getName()); System.out.println("Person 1 is null: " + (person1 == null)); } } class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } }

Output: 

Person 2 name: John  
Person 1 is null: true

3) Assign no value to the object: Lastly, you can allot no reference value to an object, known as an anonymous object. Below is a program to print an anonymous object in Java and prove it is dereferenced. 

Program: 
 

public static void main(String[] args) { // Declare an anonymous object of the Person class Person p = new Person("John", 25); // Print the details of the anonymous object System.out.println("Name: " + p.name); System.out.println("Age: " + p.age); // Dereference the anonymous object p = null; // Try printing details of the anonymous object // This will result in a NullPointerException //because the object has been dereferenced System.out.println("Name: " + p.name); System.out.println("Age: " + p.age); } } class Person { String name; int age; public Person(String name, int age) { this.name = name; this.age = age; } }

Output: 

Name: John  
Age: 25  
Exception in thread "main" java.lang.NullPointerException  
at AnonymousObjectDemo.main(source.java:15)

Garbage Collection Methods 

A dereferenced object makes it a valid candidate for Garbage Collection, but it doesn’t promise that JVM will make GC act upon it. Here are specific methods to trigger the GC within a Java program. 

1) gc() Garbage Collection method: It’s used to initiate a cleaning process within a program. This method is found in runtime and system classes and acts as a signal to the GC. You are not required to call GC manually, as JVM performs this automatically. However, this code proves it is possible to do so manually. Below is a Java program using the gc() method for collecting dereferenced objects. 

Program: 
 

public class GarbageCollectionExample { public static void main(String[] args) { // Create an object Object obj = new Object(); // Set obj to null to make it eligible for GC obj = null; // Call garbage collector to free up memory System.gc(); // Output message to indicate when garbage collection is done System.out.println("Garbage collector has run"); } }

Output: 

Garbage collector has run

2) finalize() Garbage Collection method: This method is used every time before a collection process to perform some cleanup operations. This method is defined within the object class. It's important to note that the GC process is still automated in Java. This means there is no guarantee the JVM will collect an object. Below is an example of a program which uses finalize() method in GC.   

Program:   
 

public class GarbageCollector { public static void main(String[] args) { GarbageCollector obj1 = new GarbageCollector(); GarbageCollector obj2 = new GarbageCollector(); obj1 = null; obj2 = null; // Run the garbage collector System.gc(); } // Override the finalize() method to perform cleanup operations @Override protected void finalize() throws Throwable { System.out.println("Object is being garbage collected"); // Perform some cleanup operations here // ... } }

Output: 

Object is being garbage collected  
Object is being garbage collected

Learn to develop your first web application with Web Development using Java Training course! 

Advantages of Garbage Collection in Java 

Java Garbage Collection provides several key benefits for memory management in Java applications:

a) Automatic Memory Management: Garbage Collection automates the memory management process, alleviating the need for developers to manually allocate and deallocate memory.

b) Prevention of Memory Leaks: By automatically reclaiming memory occupied by objects that are no longer referenced, Garbage Collection helps prevent memory leaks.

c) Increased Productivity: Developers can concentrate on application logic and features without extensive concerns about memory management, leading to higher productivity and faster development cycles.

d) Enhanced Application Stability: Automatic memory management reduces the likelihood of memory-related errors, such as segmentation faults or access violations, thereby enhancing application stability.

e) Adaptability to Varied Workloads: Java offers different Garbage Collection algorithms to suit diverse application workloads and requirements. This flexibility allows developers to choose the most suitable algorithm for their specific needs.

f) Optimised Performance: Efficient Garbage Collection algorithms, when properly tuned, contribute to optimised performance by minimising pause times and ensuring that the application spends more time executing useful code.

What Events Trigger Java Garbage Collection? 

An object in a programming language becomes eligible for Garbage Collection when it is no longer referenced by any part of the program. Automatic Garbage Collection is handled by the progmming language's runtime environment to reclaim memory.

In most modern programming languages, this process is automatic. The runtime environment periodically scans the heap, the memory area used for dynamically allocated objects, to identify objects no longer reachable from any active part of the program. Once identified as unreachable, these objects are marked as garbage, and their memory can be reclaimed.

The timing of Garbage Collection depends on the specific algorithm used by the runtime environment. Some algorithms are more aggressive and reclaim memory quickly, while others may delay to optimise performance. Generally, programmers do not need to manually manage memory, as the runtime environment handles this automatically.

What is the Difference Between Garbage Collection and Memory Leak?

Garbage Collection and memory leaks are both related to memory management in computer programs, but they have different meanings and implications. Garbage Collection is typically performed by the programming language or runtime environment to ensure that programs do not consume more memory than necessary. It identifies and reclaims memory that is free to be used by other parts of the program or by other programs running on the computer.

A memory leak, on the other hand, occurs when a program fails to release the memory it has allocated, even when that memory is no longer needed. Consequently, the program continues to consume memory over time, eventually leading to the depletion of available memory. This can cause the program or the entire operating system to crash. Memory leaks are usually caused by bugs in the program and can be challenging to identify and fix.

Here is a table illustrating the above differences:
 

Aspect	Garbage Collection	Memory Leak
Definition	Automatic process of reclaiming unused memory	Failure to release allocated memory no longer in use
Performed by	Programming language or runtime environment	Program code
Purpose	To free up memory that is no longer needed	Results in gradual memory consumption over time
Impact on memory	Prevents unnecessary memory consumption	Leads to depletion of available memory
Cause	Part of the language's memory management system	Bugs in the program code
Detection	Managed automatically by the runtime environment	Difficult to identify and fix
Consequences	Ensures efficient memory usage	Can cause program or system crashes

 

Conclusion 

We hope after reading this blog, you were more informed about Garbage Collection in Java. Garbage Collection is an important aspect of programming that gives developers great ease thanks to its Automated Memory Management. You will also better grasp generations of objects in heap memory and their scope. Lastly, you will be more familiar with methods used to invoke Java Garbage Collection. Thank you for reading. 

Wish to learn more? Try Java Programming And Software Engineering Fundamentals Training.