Sunday, 1 April 2012

What is Garbage Collector? How and when does it run?

The garbage collector takes care of bulk of the memory management responsibility, freeing up the developer to focus on core issues. The garbage collector is optimized to perform the memory free-up at the best time based upon the allocations being made.

It can track when the unmanaged resource needs to be terminated, but it does not have information on how to terminate the resource and free up the memory. For clean-up of these resources, the framework provides destructors in C++, Finalize method in Java and Dispose method in C#, Delphi. The developer must override these methods to release and terminate the unmanaged resources.

When the Garbage collector executes, it does not delete objects which have the Finalize method overridden. Instead, it adds them to a separate list called the Finalization queue. A special runtime thread becomes active and calls Finalize methods for these objects and then removes them from this list. When the garbage collector runs for the next time, these objects are terminated and the memory is released.

Strong and Weak References:

Strong References: An object for which references can be found by garbage collector is called strong references. These type of objects cannot be removed by garbage collector.
Weak References: An object for which references cannot be found by garbage collector is called strong references. Only these types of objects can be removed by garbage collector.

Garbage Collector in dotnet:

In .NET, Garbage Collector is maintained by CLR. The process of GC is to reclaim the memory of objects which is no longer referenced by our program. Next thing is GC runs undeterministicly because of that we can't assure we the object will be released from the Heap Location. But the CLR maintain a Logical Pointer to every object which referenced by our program. In some amount of time the GC look out the objects which is reachable from Logical Pointer. Whichever object is reachable from pointer it create a map those objects. After that it will reclaim the memory of objects those are not reachable from the pointer. This is the process of how the GC clears the memory of Object.

1 comment:

  1. I thought this was a Java article by heading :) nevertheless Garbage collection in Java is also similar to what you mention here. Even Java has Weak and Strong References.