Java线程和垃圾回收

Question

I have read in countless places that running threads are garbage collection roots (ie they reside on the stack, the GC identifies them and traces through them to determine if the objects inside them are still reachable). Further more, a GC root will never be garbage collected itself.

My confusion is here: If the objects allocated from within a thread can never be garbage collected until the thread is stopped, how then is anything garbage collected in single-threaded programs where the only thread is the main thread ?

Clearly I'm missing something here.

Answer 1

Objects are in the heap, regardless which thread created them.

Objects may be reachable through references . Some of these references can be on the call stack of one or more threads.

An object can be collected when there are no more references to it, regardless whether is allocating thread is still running or not.

For example, the thread below repeatedly allocates new StringBuilder objects. During a call to foo(), the thread has references on its call stack to a StringBuilder object. When foo() returns, there are no further references to the StringBuilder object. Therefore, that object is no longer reachable, and is eligible for garbage collection.

Thread thread = new Thread( new Runnable() {
    @Override
    public void run() {
        while ( true ) {
            foo();
        }
    }

    public void foo() {
        StringBuilder strBuilder = new StringBuilder("This new object is allocated on the heap.");
        System.out.println( strBuilder );
    }
});

thread.run();

Answer 2

First, a thread (stack) is only a GC root while it is alive. When the thread terminates, it is no longer a GC root.

My confusion is here: If the objects allocated from within a thread can never be garbage collected until the thread is stopped, how then is anything garbage collected in single-threaded programs where the only thread is the main thread ?

Your premise is incorrect.

It doesn't matter which thread allocates an object. What matters is whether an objects allocated by your thread remains reachable . If it become unreachable (for example, if you didn't put the object's reference into a local variable) ... then it can be collected.