Garbage collector and circular reference

Question

Consider these two classes:

public class A
{
     B b;
     public A(B b) { this.b = b; }
}

public class B
{
     A a;
     public B() { this.a =  new A(this); }
}

If I have classes designed like above, would the objects of such classes be collected by Garbage Collector (GC)?

Suppose I do this:

void f()
{
     B b = new B();
}

In this method, I create an instance of B called b, and when the method returns, b goes out of scope, and the GC should be able to collect it, but if it were to collect it, it would have to collect a first which is the member of B, and to collect a, it needs to collect b first which is the member of A. It becomes circular. So my question is : is such circular reference going to prevent GC from collecting the objects?

If yes, then how can we avoid this problem? How can we make sure that we don't have circular reference in our class design? Is there any tool (or compiler option) that helps us detecting circular reference?
If no, where and why do we use WeakReference class? What is its purpose?

Have a look here http://stackoverflow.com/questions/400706/circular-references-cause-memory-leak — NoWar, Jan 12 '12 at 18:49
At least logically one of the references is always going to be weak: In your example, cleary `A` cannot depend on `B`, because `A` must get made first, as a member of `B`, and so `A` can only hold a weak reference to `B`. Thus it is safe to destroy `B` first and then `A`. Arguing recursively, every computer program must be thus. There can never be a *true*, fully symmetric circular dependence. — Kerrek SB, Jan 12 '12 at 18:50
@KerrekSB: I agree with that logic. But that is viewed from the point of creation. Is the GC going to analyse this (i.e the code in each methods of such classes, after all only then it can reach at that conclusion)? I mean, if you see the objects after they've been created, then it looks very much problematic. — Nawaz, Jan 12 '12 at 18:55
`why do we use WeakReference class? What is its purpose?` I use it -for example- for caching data(in a dictionary). If it is alive ,good, if not, I load it again at first request. — L.B, Jan 12 '12 at 18:57
@Nawaz: I agree, and I have no idea how a GC would do this (though Dmitry's link explains a good approach). Personally I feel on a fundamental level that circular references are "wrong" somehow, for the above reasons... — Kerrek SB, Jan 12 '12 at 18:58
@KerrekSB I don't really get your point. It does not matter when they are created, if they use one another to perform any action, they depend on each other. Memory at A points to B, memory at B points to A. This is circular reference no? At any one state, you are either at A or at B. It does not matter that you were at A first, or second. Unless you are referring to some mathematical notion I am not aware of, I very well think it is perfectly right to refer to this as Circular Reference. — Didier A., Oct 23 '12 at 17:33

score 108 · Accepted Answer · edited May 03 '22 at 21:04

The .NET garbage collector can absolutely handle circular references. The very high level view of how the garbage collector works is ...

Start with locals, statics and GC pinned objects. None of these can be collected
Mark every object which can be reached by traversing the children of these objects
Collect every object which is not marked.

This allows for circular references to be collected just fine. So long as none of them are reachable from an object known to be uncollectable then the circular reference is essentially irrelevant.

Note: I realize I've left out many fun details in order to keep this answer simple and direct

Wouldn't that be computationally expensive – user4951 Nov 03 '17 at 16:42 — user4951, Nov 03 '17 at 16:42

score 39 · Answer 2 · edited Jan 12 '12 at 18:53

39

No, This won't be a problem because GC can handle Circular References

MSDN Says

If a group of objects contain references to each other, but none of these object are referenced directly or indirectly from stack or shared variables, then garbage collection will automatically reclaim the memory.

edited Jan 12 '12 at 18:53

hunter

62,308
19
113
113

answered Jan 12 '12 at 18:48

Haris Hasan

29,856
10
92
122

score 7 · Answer 3 · answered Jan 12 '12 at 19:00

Several answers already explained that circular references are not a problem.

As to the weak references - the reason to use them is caching.

When GC walks object dependency trees he ignores weak references. In other words if the only reference to an object is a weak one(s), it will be garbage collected, but if there was no garbage collection between reference creation and your attempt to use, you can still access the object.

score 6 · Answer 4 · answered Jan 12 '12 at 18:48

No that circular reference will not affect the garbage collector, and it will be perfectly able to collect the instance of B.

The garbage collector knows that no-one can reference the instance of B after going out of scope, and consequently, no-one can use the instance of B to indirectly reference A.

Garbage collector and circular reference

4 Answers4

Linked

Related