Extends Thread versus Implements Runnable... difference?

Question

I've seen them both used and to the naked eye it seems to be pretty much the same (besides the execution).
Can anyone tell me the major differences between the two methods of multi-threading and how/if one is better?
Do you ever make a deliberate choice to use Extends over Implements (or vice versa) for a specific task?

Answer 1

For the record, I've normally used extends Thread, and
seeing the light that in doing that, I can only extend
one class, I'm looking into the alternative.
Are...
Thread t1 = new Thread(new myRunnableThread());
Thread t2 = new Thread(new myRunnableThread());
t1.start();
t2.start()
and...
MyExtendedThread t1 = new MyExtendedThread();
MyExtendedThread t2 = new MyExtendedThread();
t1.start();
t2.start();
equivalent?
equivalent meaning that they are equally fast? I'd say no, because in the first example you are creating a thread and a runnable, in the second you are only creating a thread.
>
Additionally, consider -
public class myExtendedThread extends Thread {
ServerSocket ServiceConnectSocket = new
ServerSocket(4000);
NotificationListener mainThread;
public myExtendedThread(NotificationListener
_mainThread) {
mainThread = _mainThread;
public void run()  {
      while(true)
             if (ServiceConnectSocket != null)
                 return;
             try
                 Thread.sleep(5000);
ServiceConnectSocket = new
ectSocket = new Socket(host, port);
                 ServiceConnectSocket.close();
                 mainThread.serviceReady();
             catch (Exception e)
>
This thread basically tries to connect to a socket,
and when it does, it closes the socket it made,
notifies another thread (passed in at the constructor)
and returns.
My question is on what happens when Threads return.
When this thread returns... what happens exactly?
What if mainThread.serviceReady restarted that
t thread? Would it start a NEW thread or just re-run
the run() of the old one?
Once a thread returns, how long before Garbage
Collection will free up the memory it used?
When the run method returns, the thread is dead. It is not reused automatically. You have to implement some type of thread reuse like my code above.
I would assume that the normal GC rules apply. Each JVM can decide to cleanup the thread whenever it feels like it.