Creating a Thread from a Thread

[angstrem]

I have the following code:

        Thread t = new Thread(){
 
            public void run(){
                System.out.println("I'm called!");
            }
 
        };
 
        for(int i = 0; i < 10; i++){
            t.start();
            t.join();
            t = new Thread(t);
        }

The question is, why the run method of a thread is invoked only twice (instead of 10 times)?

[Norm]

Please post a small, complete program that compiles, executes and shows the problem.

[angstrem]

In fact, this already is a small, complete program. Just wrap the code in the main method and that's it.

[Norm]

Please post a complete program that compiles, executes and shows the problem. It is important that I have exactly the same code that you are executing so that I can see what the code does when it executes. If I change it, it could be different.

[angstrem]

OK, here's the full code:

public class Program {
 
	public static void main(String[] args) throws InterruptedException {
		Thread t = new Thread(){
			public void run(){
				System.out.println("I was called!");
			}
		};
 
		for(int i = 0; i < 10; i++){
			t.start();
			t.join();
			t = new Thread(t);
		}
	}
 
}

The problem is that "I was called!" appears only 2 times on the screen. Instead of 10.

[Norm]

Look at the output from this code:

public class Thread_Program {
 
	public static void main(String[] args) throws InterruptedException {
 
		Thread t = new Thread(){
			public void run(){
				System.out.println("I was called! threadname=" + Thread.currentThread().getName());
			}
		};
 
		for(int i = 0; i < 10; i++){
                       System.out.print(i + " created t= " + t.getName() + " t.run() on next line ");
                        t.run();   // to print msg
			t.start();
			t.join();
			t = new Thread(t);
		}
	}
 
}

The use of t the first time is with the override of run()
for the rest of the times, the run() method is the empty default from the Thread class.

[angstrem]

But if I pass a Runnable to a Thread constructor, the Runnable's run() method will be called on thread's start. Thread implements Runnable. Hence, when I say t = new Thread(t) the new thread must run the run method of 't' (who is in the constructor).

[Norm]

new thread must run the run method of 't' (who is in the constructor).

The first time. The second time t is different.

Look at the output from the code I posted.

[jps]

Watch your code run in a debugger where you can see what happens. That is probably the best way to "get it" with the code you posted.

[angstrem]

Norm, jps, thank you very much! Now I see it. Actually, it becomes very, very obvious in a debugger. So in the first iteration we had a direct call to the target run() method. At the end of this iteration this thread is passed to the standard system thread constructor as a Runnable. In the 2nd iteration the run() on 't' causes the run() on a thread from 1st iteration. In 3rd iteration call to run() on 't' also causes a call to a thread from a previous iteration, and it is a standard system thread with an empty run().

[neha34]

There is no such thing as a parent-child relationship between threads in Java. Once created, they have a life of their own.
Regarding performance, you may want to use an ExecutorService to control the number of threads created in your application. Too many threads will kill performance for sure. See the Executors class too. I sure they will help you....
The way you are creating threads is perfectly ok if it is only a few. Otherwise, executor services are the preferred method.

[copeg]

There is no such thing as a parent-child relationship between threads

a) Technically, there is such a thing via the ThreadGroup class b) what does this have to do with the original posters question? Please stop posting links to spurious non-java doc, non-oracle, 3rd party websites - doing so as a new user, resurrecting several week old posts makes it look very much like self promotion - aka spam. Continue to do so and further action will be taken.