— Scott McNealy, Sun Microsystems Chairman, President and ceo

I’ve seen examples that don’t use a separate 
Runnable implementation, but instead just make a 
subclass of Thread and override the Thread’s run() 
method. That way, you call the Thread’s no-arg 
constructor when you make the new thread;
Thread t = new Thread(); // no Runnable
A: 
Yes, that is another way of making your own 
thread, but think about it from an OO perspective. 
What’s the purpose of subclassing? Remember that 
we’re talking about two different things here—the 
Thread and the thread’s job. From an OO view, those 
two are very separate activities, and belong in separate 
classes. The only time you want to subclass/extend 
the Thread class, is if you are making a new and more 
specific type of Thread. In other words, if you think of 
the Thread as the worker, don’t extend the Thread class 
unless you need more specific worker behaviors. But if 
all you need is a new job to be run by a Thread/worker, 
then implement Runnable in a separate, job-specific 
(not worker-specific) class.
This is a design issue and not a performance or 
language issue. It’s perfectly legal to subclass Thread 
and override the run() method, but it’s rarely a good 
idea.
Q: 
Can you reuse a Thread object? Can you give it 
a new job to do and then restart it by calling start() 
again? 
A: 
No. Once a thread’s run() method has completed, 
the thread can never be restarted. In fact, at that 
point the thread moves into a state we haven’t talked 
about—dead. In the dead state, the thread has 
finished its run() method and can never be restarted.
The Thread object might still be on the heap, as a 
living object that you can call other methods on (if 
appropriate), but the Thread object has permanently 
lost its ‘threadness’. In other words, there is no longer a 
separate call stack, and the Thread object is no longer 
a thread. It’s just an object, at that point, like all other 
objects.
But, there are design patterns for making a pool of 
threads that you can keep using to perform different 
jobs. But you don’t do it by restarting() a dead thread.

---