Garbage collecting threads

Question

I am doing the following:
public class MyClass {
     private Thread t = null;
     public class testThread extends Thread{
       public void run(){
              String logName = this.getClass().getName();
              Logger.Print( logName );  // Basically prints logName to file
              for( int i = 1; i<4; i++){
                     try{
                       Thread.sleep(100)
                       [do stuff]
                       Thread.sleep(100);
                     catch(InterruptedException e) { }
       public callThread(){
           if ( t != null ){
                    if( !(t.isAlive()){
                           t = new TestThread();
                           t.start();
           else{
                           t = new TestThread();
                           t.start();
} What, I want to happen is a thread to finish and after that a new one to start, and once the old thread does not have any variable assoiciated to it anymore, it should get garbage collected as far as my java understnading goes, this is exactly what should happen, in duo time whenever the garabage collecter decides so. This is a very long time running program.
And the log shows the names of the threads like Thread-1 , Thread-2, Thread-3 , Thread-4, basically this name is increased by one everytime the function callThread is called and the old thread finished running, is there a limit to how many times I can call it like if it is called 10 billion times, will I have Thread-10000000000 in my log? and will the garbage collection work as I think? I am a c++ programmer so I do not trust it 100%, I really feel like adding delete t; so I can feel confident it is really gone before I do a t = new TestThread(); hehe C++ sickness??
Please give me advice on this!!! and I will be very happy!
Edited by: dakiar on Mar 19, 2008 8:18 AM

Answer 1

dakiar wrote:
What, I want to happen is a thread to finish and after that a new one to start,Use join(), rather than looping and checking isAlive, in order to determine when a thread has died.
while (true) {
  Runnable r = new MyRunnable(); // You have no reason to extend Thread. It's preferable to implement runnable.
  Thread t = new Thread(r);
  t.start();
  t.join();
and once the old thread does not have any variable assoiciated to it anymore, it should get garbage collected as far as my java understnading goes,It will become eligible for GC. There's no guarantee when or even if it will actually be GCed, other than that GC will at least happen before OutOfMemoryError.
And the log shows the names of the threads like Thread-1 , Thread-2, Thread-3 , Thread-4, basically this name is increased by one everytime the function callThread is called and the old thread finished running, is there a limit to how many times I can call it No.
like if it is called 10 billion times, will I have Thread-10000000000 in my log? Perahps. Or if Thread uses an int then it might wrap around to Integer.MIN_VALUE and give Thread--2147483648.
You know you can assign your own names to the Threads.
and will the garbage collection work as I think? It will work fine, and that has nothing to do with thread names.
I am a c++ programmer so I do not trust it 100%,So, you think that you managing memory ad-hoc in every program you write when you're trying to focus on implementing the business requirements of your app will be better at it than the guys who were specifically focussed on writing memory management that would be handled consisently by the computer, and has been continuously refined, not to mention tested by thousands of Java developers over the last dozen or so years?
I really feel like adding delete t; You can't and you don't need to.