Garbage collection of the object created in infinite loop

Question

Hi,

I have a very basic question.

I write a loop like this:

while(true)
{
   MyTestClass myObject = new MyTestClass();
}

1. When will be the object created in the loop, garbage collected?
2. Also, for every iteration, is it that the new memory location is allocated to the myObject reference?
3. What if i write myObject = null; at the end of every iteration?

Answer 1

1. whenever GC feels like it, frankly; the variable is never read, so it is always eligible
2. myObject is the variable - that has a fixed position on the stack for the reference; however, each new MyTestClass() is a different object, created somewhere in the available heap space; different each time
3. no difference whatsoever; strictly speaking there are some complexities involving the actual declaration point of the variable (in IL) and how while is actually implemented - but that would only show after exiting the loop. And since on each iteration you immediately allocate it, there is no tangible difference here

Answer 2

When will be the object created in the loop, garbage collected?

At some point after the last reference to it is removed. A new reference is created and removed on each loop iteration, so the GC is free to collect these objects when it wants. In practice, this is likely to happen when your program completely fills generation zero.

Also, for every iteration, is it that the new memory location is allocated to the myObject reference?

Yes.

What if i write myObject = null; at the end of every iteration?

It won't make any difference. Setting myObject = null; removes that reference to the object, but the reference is removed anyway when the myObject variable is reassigned in the next loop iteration.

Answer 3

Let's clear a few things up. Every time you hit the inside of the loop, myObject will be allocated to a new address. So all this loop ever does is allocate new memory addresses for a single variable name. Thus:

1. The GC will garbage collect all of the previous allocations, probably almost immediately since the variable is never used.
2. Yes.
3. Doesn't matter. The variable is still unused.

Answer 4

As an addition to all the others answers:

You could make your class a struct. Then it will be on the stack and be thrown away for each iteration. If your struct makes new classes then you are back to square one though. And if your struct is large it could affect performance negatively but otherwise if it is small it could affect the performance positively.

Answer 5

Let's add some code that actually uses the object to make it clearer what really happens:

while(true) {
  // Here a new instance is created in each iteration:
  MyTestClass myObject = new MyTestClass();
  // Here the instance is still in use
  // until here:
  myObject.CallSomething();
  // Here the instance isn't used any more,
  // so the GC can collect it if it wants to.
  // Setting the reference to null here:
  myObject = null;
  // is useless, as the GC already knows that the
  // instance is unused before that time.
}