Articles → .NET → Garbage Collector

Garbage Collector

Each program uses several resources. To use the resource memory must be allocated to the resource.

The steps required to access the resource is

Allocate memory to resource.
Initialize the memory to set the initial state of the resource.
Use the resource.
Tear down the state of the resource.
Free the memory.

Garbage collector knows when to free the memory.

Managed Heap

A managed heap is the long strip of memory. Dotnet maintains the pointer to the next available address in the managed heap. When .net is asked to create a new object, it allocates the required space for the object and advances the pointer

Click to Enlarge

.Net CLR requires all the resources to be allocated to the managed heap. You never free objects from the managed heap. Objects are automatically freed when no longer needed by the application.

Application Roots

Application roots specifies the storage location of objects on the managed heap i.e. the pointers to the object at the managed heap. If there is any object on the managed heap that doesn’t corresponds to any application root then that object will be considered as garbage. The list of active roots are maintained by JIT and CLR.

The implementation consists of 2 phases: Mark and Compact.

Phase I: Mark - Find The Memory That Can Be Reclaimed.

Initially when the garbage collector starts running it assumes that all the objects in the heap are garbage.

Steps in phase I are:-

GC identifies live application roots.
It starts walking the roots and graph all the objects reachable from the roots.The objects that are not reachable through the application roots is considered as garbage.

Phase II: Compact - Move All The Live Objects To The Bottom Of The Heap, Leaving Free Space At The Top.

Process in Phase II is :-

GC now shifts the non garbage objects objects down in the memory.Moving the objects in the memory invalidates all the pointers to the object. So GC modifies the application root so that the pointer points to the new location.

Finalize

After these 2 steps .net garbage collector removes the object and reclaim the memory. But when it comes to unmanaged resource then .net GC uses Object.Finalize method.

Garbage Collector Performance Optimizations

Weak References
Generations

Weak References

The garbage collector cannot collect the object when the application code can reach the object. The application is said to have a strong reference to the object.

A weak reference means that GC can collect the object still allowing the application to use the object.

When you use weak reference then application can still obtain strong reference to prevent it from collected. Weak reference is useful when an object uses a lot of memory.

Let us consider an object A uses a lot of memory. When the user is busy in doing something else and not using this object, a weak reference of the object is created. When the user switches back to the object the application tries to obtain the strong reference of the object and if successful avoid reconstructing the object.

Generations

Generation in garbage collectors is the categorization of objects based on their age i.e., how long the object is there in the memory. The generations are numbered from 0 to 2 where 0 is the youngest and 2 is the oldest.

Generation 0 → This generation contains those objects which are frequently collected by the garbage collector
Generation 1 → The objects that survived the garbage collection in Generation 0 are promoted to Generation 1
Generation 2 → This Generation contains the long-lived objects that survived multiple garbage collection

The purpose of categorizing the objects into Generations is to optimize garbage collection. Generation 0 experiences more frequent garbage collection as compared to Generation 1. Similarly, Generation 1 experiences more frequent garbage collection as compared to Generation 2.

Are Primitive Types Collected By The Garbage Collector?

No. The garbage collector is only for reference types and not for primitive types.

Empty Destructor

The destructor is used to clean up the unmanaged resource. When you create an empty destructor, it will create unnecessary overhead that leads to performance issues.

So, it is recommended to use a destructor when you want to manage unmanaged resources such as file handles or network connections.

Can We Force The Garbage Collector?

Yes, we can use GC.Collect() method to force the garbage collector. But, you should not force the Garbage Collector unless your physical memory RAM is scarce and your application needs more memory.

What Is The Memory Leak?

A memory leak in .NET (or any programming language) refers to a situation where a program unintentionally allocates memory resources but fails to release them even after they are no longer needed.

What Happens When You Use A Destructor In .NET

Stage 1: Marking Phase

The GC identifies that the object has a destructor and moves it to the finalization queue, but does not free the memory yet.

Stage 2: Finalizer Thread Executes

A separate thread (the finalizer thread) executes the destructor at an unspecified time after the object is no longer reachable.

Only after the destructor has run, the object is marked for collection in the next GC cycle.

Posted By -	Karan Gupta

Posted On -	Thursday, June 10, 2010

Updated On -	Monday, May 6, 2024

Query/Feedback

Your Email Id		**

Subject		*

Query/Feedback	Characters remaining 250	**