GC何时采取行动

Question

I wonder what are the situations of the GC to free the memory of a pointer.

For example:

public class Test
{
    public List<int> list1;

    public void test()
    {
        List<int> list2 = new list<int>();

        list2.Add(1);
        list2.Add(1);

        list1 = list2;
    }
}

The GC was suppose to free the memory of list2, does it because another element share the same address of list2? After the run of test()

What are the situations which the G will free the memory of an element.

Answer 1

In your example you create list2 as a local variable, but then you retain the reference to the underlying object in list1 before the method exits, which means the object you created in test() won't be collected (until list1 gets out of scope or changes the reference). Your object is ready to be collected only when there are no strong references to it (read about weak references if you want to know more on this subject).

Even when the object is ready to be collected, garbage collector will only run when:

• There is low physical memory (OS will tell your app when there is memory pressure)
• Memory used by allocated objects surpasses a certain threshold which is adjusted dynamically
• New allocation cannot be made because not enough memory available
• GC.Collect() was called explicitly
• ..

Answer 2

list1 retains a reference to the list after test() completes and will retain that reference for the lifetime of the instance of Test . The GC will not free up that list therefore until sometime after there is no longer any reference to Test .

When that "sometime after" occurs can be viewed as non-deterministic. It'll do it as and when it wants to. It almost certainly won't do it straight away.

Answer 3

does it because another element caught the address if list2?

No, it because list2 is no longer available out of scope of test(..) method.

Worth mantioning, that the pointer becomes invalid, but the memory it refers to is still "alive". Because there is another list1 that refers to the same memory

list1 = list2;

and list1 is a global var, so is not subject for destruction in this concrete case .

And more: it's not a must that GC actually frees a memory. Correct to say that the memory is marked to be garbage collected, but will be it actually cleaned or not is subject of other validations.

Answer 4

.NET GC is a tracing, generational, mark-and-sweep collector .

It will never collect objects which are reachable , where reachable objects are ones:

1. which are referenced from anywhere in the call stack (that is, all local variables and parameters in the functions currently being invoked), and any global variables. These objects are called roots .

2. which are referenced by other reachable objects.

In your case, the new List<int>() statement creates a new list instance in memory, which is initially referenced by list2 . If you didn't assign it to list1 , it would have been eligible for collection as soon as list2 went out of scope (and then collected some time in the future).

Since you made your list1 field reference that same instance, after leaving the test1 method you are still left with a strong reference to that (one and only) object instance.

Answer 5

Your terminology is a bit mixed so I'll try to correct that.

Firstly, the GC runs automatically and asynchronously. It is also 'smart'. It will only run when required, to minimize the number of collection attempts. You should never have to interact with it.

The GC was suppose to free the memory of list2, does it because another element caught the address if list2? After the run of test()

list1 is a class member . list2 is a local variable . list1 is always null - there is nothing to collect. A reference ( no pointers in c#!) to list2 is created when you assign it to list1 . list2 will now only be created when the class Test is collected.

Answer 6

I'm not sure if I understand your question correctly, but the GC will remove the content of list2 because it is kept alive for only a short amount of time, due to it living on the stack and not the heap.

So, if you're wondering if the GC clears it because you've assigned list1=list2, then no. List2 would be kept alive as well but it gets killed off due to the method ending. :)

Here is a small blogpost that goes a bit more in-depth on the GC: http://it-ca.net/blogdylan/?p=354