Garbage Collection

The garbage collector (GC) serves as an automatic memory manager in the common language runtime (CLR). When a class object is created at runtime, certain memory space is allocated to it in the heap memory. However, after all the actions related to the object are completed in the program, the memory space allocated to it is a waste as it cannot be used. In this case, garbage collection is very useful as it automatically releases the memory space after it is no longer required.

Advantages of Garbage Collection

• You don’t need to free memory manually while developing your application.
• It also allocates objects on the managed heap efficiently.
• When objects are no longer used then it will reclaim those objects by clearing their memory, and keeps the memory available for future allocations.
• Managed objects automatically get clean content to start with, so their constructors do not have to initialize every data field.

When Garbage Collection Works

Garbage Collection occurs if at least one of multiple conditions is satisfied. These conditions are given as follows:

• When virtual memory is running out of space.
• When allocated memory is suppressed acceptable threshold (when GC found if the survival rate (living objects) is high, then it increases the threshold allocation).
• When we call GC.Collect() method explicitly, as GC runs continuously, we actually do not need to call this method.

Generations

Memory is divided into spaces called generations so it can handle long-lived and short-lived objects. Garbage collection primarily occurs with the reclamation of short-lived objects that typically occupy only a small part of the heap. There are three generations of objects on the heap:

Generation 0

This is the youngest generation and contains short-lived objects. An example of a short-lived object is a temporary variable. Garbage collection occurs most frequently in this generation.

Newly allocated objects form a new generation of objects and are implicitly generation 0 collections. However, if they are large objects, they go on the large object heap in a generation 2 collection.

Most objects are reclaimed for garbage collection in generation 0 and do not survive to the next generation.

Generation 1

This generation contains short-lived objects and serves as a buffer between short-lived objects and long-lived objects.

Generation 2

This generation contains long-lived objects. An example of a long-lived object is an object in a server application that contains static data that's live for the duration of the process.