A Garbage Collector is a Java program which tracked the referenced (live) objects and allowed them to keep in the heap memory whereas the memory of the unreferenced (dead) objects is reclaimed and reused for future object allocation. To understand it more practically we have to take some pictorial examples of JVM object creation and management cycle. Let’s see how does Garbage Collector work?
Object Creation and Memory Allocation:
When new objects are created by JVM then heap memory is allocated to each object. How? Let’s have a look of below example.
Let’s consider the limit of Eden is 5 i.e. only 5 objects can accommodate in Eden at a time. The name of these objects as A, B, C, D and E. When these 5 objects are created, respective memory is allocated to them in Eden under the young generation.
When Eden limit is over:
After some time, some of the objects become alive and some of the objects become dead. You can call the live object as referenced objects because those objects are referenced by some other objects and will be used in the near future. The objects who become dead are called as unreferenced objects.
In our example, you can see object A, B and E are live objects whereas object C and D are dead objects.
Minor Garbage Collection 1:
The minor garbage collection is an intermediate process which runs when Eden memory limit is over. The simple definition of Minor GC is to move the live objects from Eden to Survivor 1 (or Survivor 2) when Eden memory limit is over. There is no impact on old (Tenure) generation due to the execution of minor GC. During minor GC, 2 tasks happen:
- Moving the live objects from Eden to S1 or S2
- Remove the dead objects and reclaim the memory for new objects
- In the figure you can see that object A, B and E have been moved to S1 and memory is reclaimed by removing the dead object C and D.
New Object Creation and Memory Allocation along with unreferenced objects:
One more time the first step repeats and new objects are created by JVM and heap memory is allocated to each object. This time new objects F, G, H, I and J are created and Eden memory space is allocated to them. The only difference in the first step and this step is; this time some objects are available in the S1 as well, so now we have a total of 8 objects. During this activity, some of the objects in the Eden as well as in S1 may dead like object ‘B’ and ‘I’.
Minor Garbage Collection 2:
Since the Eden memory is full so this situation again leads minor GC. Here one point to be noted that minor GC is a periodic process whenever Eden memory limit is over and every time it does the same tasks which I have mentioned above. Now, the live objects F, G, H and J will move to S2 along with A and E which exist in S1. The dead objects B and I will be removed and Eden memory will be reclaimed.
There is one more process which takes place along with all above-mentioned activities i.e. Object Promotion. After each minor GC, the objects become old and their age keeps on increasing. When aged objects reach a certain age threshold they are promoted from the young generation to the old generation. This process is called as Promotion.
In our example you can see object A, G, J and O are promoted to the old generation after ‘n’ number of minor GC executions. The promotion process leads to fill old generation memory space. One important point to note down here some of the objects like String and Array objects are directly created in tenured generation memory space.
Major GC cleans up the old generation. The task of Major GC is as same as the minor GC, but the only difference is minor GC reclaims the memory of the young generation whereas major GC reclaims the memory of the old generation. It is also said that many major GCs are triggered by minor GCs.
A Full GC is triggered whenever the heap fills up. In such a case the young generation is swept first followed by the old generation. If the old generation is too full to accept the objects of the young generation, the young generation GC is omitted and the old generation GC (major GC) is used to clean and compact the full heap, either in parallel or serial. Either way, the whole heap is collected with a stop-the-world event.
Stop the World Event: It is a time when all the application threads are stopped until the garbage collection operation completes. Both minor and major garbage collections are “Stop the World” events. A major GC is much slower than minor GC because it involves all live objects.
You may be interested: