Java threads and garbage collector [duplicate]

Question

Possible Duplicate:
Java Thread Garbage collected or not

Consider the following class:

class Foo implements Runnable {    public Foo () {        Thread th = new Thread (this);        th.start();   }    public run() {     ... // long task   }  } 

If we create several instances of Foo by doing

new Foo(); new Foo(); new Foo(); new Foo(); 

(note that we don't keep a pointer to them).

1. Could those instances be removed by the garbage collector before the thread in run() ends? (In other words: is there any reference to the Foo objects?)

2. And, in the other hand, will those instances be removed by the GC after the thread in `run()' ends, or are we wasting memory ("memory leak")?

3. If either 1. or 2. are a problem, what's the right way to do it?

Thanks

Answer 1

1. Any object which is referenced by an active thread may not be de-allocated.
2. Yes, instances will be removed by the GC after the thread in `run()' ends.
3. No prob.

Answer 2

1. Could those instances be removed by the garbage collector before the thread in run() ends? (In other words: is there any reference to the Foo objects?)

No. While the constructor is running GC won't collect the object. Otherwise even the simplest:

Customer c = new Customer(); 

could fail while the constructor of Customer is running. On the other hand when you start a new thread, the thread object becomes a new GC root, so everything referenced by that object is not a subject to garbage collection.

1. And, in the other hand, will those instances be removed by the GC after the thread in `run()' ends, or are we wasting memory ("memory leak")?

Once the thread is done, it is no longer a GC root. If no other code points to that thread object, it will be garbage collected.

1. If either 1. or 2. are a problem, what's the right way to do it?

Your code is just fine. However:

• starting a new thread in a constructor is a poor idea from unit-testing point of view

• keeping a reference to all running thread might be beneficial if e.g. you want to interrupt these threads later.