How does GC handles Circular References ?

This is very interesting question. Let me explain you Obj A -> Obj B ( object A refers to object B ) , Obj B -> Obj C ( object B  refers to object c ) and Obj C -> Obj B( object C again refers to Object B). So this is circular dependency.

So now when object A goes out of scope GC will collect this as object B refers by object A so this will also be collected but this also refers by Object C.... Grrrrrr lot of confusion huh ?
How GC takes care of this ?

GC is so smart. It doesn't bother about references. GC traverse by application roots now u must be thinking what are the application roots ?

Application roots are the entry points for GC and they referenced objects( if they exist otherwise null). So here is the list of application roots:

1. Static objects and static fields
2. Global objects
3. Reference on stack to method parameters
4. Reference on stack to local objects
5. Reference to objects that are in managed heap( CPU registers)

So using these roots GC starts its execution to the program and use its unique marking technique. It traverse from root to child and mark the objects those are not going to be collected. Let's say in between A goes out of scope so it means GC will not mark A. If object A is not marked then B and C will not be marked because A was the entry point. So doesn't matter whether there is circular reference or not next time when GC runs it will collect all these objects because there is no way around to reach those objects.

GC is a non deterministic process which runs only when it needs to run for a particular generation and collect those objects those are not marked.

Hope you enjoyed reading this article.

Read More