The Runnable interface is effectively Java's substitute for function  
pointers.  All the Runnable interface says about a class is that here is  
some code that can be executed.  It doesn't say anything about where that  
code should be run or when.  You can run it on a new thread or you can run  
it on the current thread - it's up to you.

If, instead of implementing Runnable you extend Thread, you are tying the  
logic to a single particular concrete thread.  You can only start a thread  
once.  With a Runnable, you can pass it to several threads and run it as  
many times as you like, even simultaneously if it's written in a way that  
makes it safe to do so.

Another point that is often made when discussing this point is that by  
sub-classing Thread you are effectively saying this class is a new *type*  
of thread, when in reality it is not, it is just a normal thread that has  
an unnecessary coupling between what it does and how it does it.  So the  
reason not to sub-class thread is not so much because it prevents  
extending another class, but because conceptually it rarely makes sense  
for your Runnable to extend *any* base class.

Dan.