What is Garbage Collection?

Declaring variables is a part and parcel of life as a programmer. It is encouraged for programmers to use variables in their code as they not only facilitate reusability, they also contribute a great deal in enhancing the readability of your code, which in turn enhances the maintainability of the code. It is also not exactly a secret that these variables being declared take up space, and also have a certain scope associated with them. So for optimized memory management it makes sense for the JVM to clear or destroy these objects once they are not needed. This process of clearing the “unwanted” variables is known as Garbage Collection(GC).

Garbage Collection in JAVA

Garbage collection in languages like C,C++ falls on the responsibility of the application developer as you have explicit tools to manually take out the trash in those languages. In Java on the other hand, the JVM does Garbage Collection automatically. JVM goes through a set of processes that determine when and where to trigger GC in the heap memory. As a Java developer, it’s imperative understanding the basics of GC and the sections of heap memory which will greatly help us in building memory efficient Java applications.

Phases involved in Garbage collection

Java garbage collection is usually done in two phases. The mark phase and the sweep phase.

Mark Phase: In mark phase the objects are classified in two ways, referenced and unreferenced. Referenced objects are the ones that are still in use and which are not out of scope. Unreferenced are the ones that are not needed by the application anymore. The unreferenced objects are “marked” for garbage collection.

Sweep Phase: In sweep phase the objects that are “marked” are deleted/cleared. Additionally, sometimes the heap also initiates something called Memory compaction (Mark-compact-algorithm) which reallocates the memory so that the remaining objects are still in contiguous memory. This process makes it so that the JVM can allocate the memory sequentially to the newly created objects. The details of the memory compaction process is out of the scope of this article so we will skip over that.

To maintain efficient garbage collection there are some garbage collection strategies that the JVM follows. The most common strategy is the generational garbage collection strategy.

Generational Garbage Collection Strategy

We will explore the generational garbage collection strategy here as it is the most common form of garbage collection used. Generational garbage collection is preferred for two main reasons.

1. The process of marking, sweeping and then compacting becomes extremely inefficient as more and more objects are getting allocated in the memory. This further increases the time to mark, sweep and compact which will lead to extremely large GC times.
2. Analysis have proved that most objects in Java applications are short lived.

For the above reasons mentioned, to make the process of GC more efficient the heap memory of Java is broken down into segments or Generations.

Young Generation:

The Young Generation is divided into three regions. The Eden Space, Survivor space zero (S0) and Survivor Space one (S1). Let us discuss the process of Garage collection from the point of application boot up.

At the start, all the newly created objects are filled in the Eden Space. Both the survivor spaces (S0 and S1) will be empty. As the Eden space fills up, a minor garbage collection cycle is triggered. All the unreferenced objects in the Eden Space are deleted and all the referenced objects are moved to S0. This is gc(0).In the next consequent Garbage collection cycle, all the referenced objects from the Eden space and the S0 space are moved into S1. After this all the unreferenced objects are deleted. The Object allocation after gc(1) will look something similar to this.

We can observe from the above image that after every gc cycle the age of the objects are incremented by 1. After the age reaches a certain threshold, the objects are moved to the next section of heap memory. We also need to know that all minor GCs are Stop the world events. This means that the application threads are stopped until the GC is completed. Typically minor GCs take less time when compared to Major GCs.

Old Generation

Eventually when the object’s age reaches a certain threshold, they are moved from the young generation to the old generation. In due course, the Old generation also fills up. When the old generation fills up and is needed to be cleaned, a major GC is triggered.

Differences between Major GC and a Minor GC

One of the major differences between a Minor GC and a Major GC is the time it takes to complete a Minor and a Major GC. While Major GCs are also stop the world events like minor GCs the amount of time that takes to complete a Major GC is so much more than a minor GC as it involves all live objects. The amount of time it takes to complete a Major GC also increases linearly with the major GC space as more space means more time for memory compaction. This means that in applications that prioritizes response time, we would need to maintain a low frequency when it comes to Major GCs . It is also worth noting that the length of the stop the world events in a major GC depends on the type of GC being used.

Full GC

A Full GC in Java Garbage collection is when both young generation and old generation GCs are triggered. A full garbage collection takes so much more time than a minor or a major GC. There can be multiple reasons as to why full GC happens. A couple of them include :

1. Heap Space filling up: A Full GC could occur before all Java heap memory has been exhausted due to the necessity of finding a contiguous set of regions for them.
2. Change in region sizes: When there is a change in region sizes (young or old) depending on the demand of memory, normally region resizing is initiated by a full GC.

Metaspace

There is an additional segment of memory which used to be a part of the heap memory and was also included in a full garbage collection. This segment of memory was called Permanent generation. In Java 8 permanent generation was changed to Metaspace and was moved away from the heap memory. The primary reason for metaspace existence is to store class metadata. It has the capability to auto increase if the class needs more space to load and store metadata.

Understanding Java Garbage collections is very important in making your java applications more efficient and also troubleshooting and fixing potential memory leaks in the system.