Question: Folks, 

I know this question has been asked before here, **though indirectly**. But it didn't answer my doubt.  

Question : [Is it legal to call the start method twice on the same Thread?](https://stackoverflow.com/questions/1215548/is-it-legal-to-call-the-start-method-twice-on-the-same-thread) 

From the [spec](http://download.oracle.com/javase/6/docs/api/), 

> 
> It is never legal to start a thread
>  more than once. In particular, a
>  thread may not be restarted once it
>  has completed execution. 
> 
> 
> 

I agree. But my code doesn't throw a [`IllegalThreadStateException`](http://download.oracle.com/javase/6/docs/api/java/lang/IllegalThreadStateException.html) which it is expected to throw on execution of following program. 

```
   public class Tester extends Thread {
        public void run() {
            System.out.print("run");
        }
        public static void main(String[] args) {
            Tester thread = new Tester();
            new Thread(thread).start();
            new Thread(thread).start();
        }
    }    

```

Q.1) I ran the above code in Eclipse. Here, since I am trying to start a new thread on the same instance, a `IllegalThreadStateException` is expected to be thrown. But it doesn't. 

Why ?

Q.2) **If at all we did start a new thread on the same instance, what harm it would do ?** 

Any help would be greatly appreciated !

Answer: 
You are NOT calling start() on the same instance. Everytime you use new you are creating a distinct instance. Hence no problem calling start().

If you did this:

```
 Thread t = new Thread(thread);
 t.start();
 t.start();

```

Then you may have a problem.
And here we see why the Executors make so much sense. 

Typical idiomatic Java would say that you shouldn't run your own threads much at all; create an executor service, and let it manage the threads. You just create Runnable instances and pass those to the executor service; you can call Runnable's run() method as often as you like, whenever and wherever it makes sense to do so, and you don't have to concern yourself with Thread management at that point.

Extending Thread is also a one-shot deal; extending superclasses in Java is expensive (since you get ONE superclass, that's it). However, you can extend as many interfaces as you like, so Runnable gives you a more powerful object hierarchy as well.