For creating a Thread we can either use Thread class or Runnable interface.

If we are extending Thread class in say aclass
we will override the run method in the Thread class.
Then we make the Thread runnable by calling start().
We are not passing any arguments (current class instace).
Neither we overriding start()
Then how will start() get to know which instance method to call??
If I'm not wrong start() in Thread class does nothing.
Is there any internal implementation to call run() whenever there is a call to start()???

Please correct me if my idea is wrong.

"
20.20.14 public void start()
throws IllegalThreadStateException

Invoking this method causes this thread to begin execution;
this thread calls the run method of this Thread object.
The result is that two threads are running concurrently: the
current thread (which returns from the call to the start
method) and the thread represented by this Thread object
(which executes its run method).
"

(http://java.sun.com/docs/books/jls/html/javalang.doc18.html#8093)

Hope it helps ....

Regds.

class MyThread extends Thread {
   public void run() {
      for(int i=0; i<10; i++) {
	     System.out.println("i="+i);
      }
   }
   //Try to override start()
   public void start() {
	 System.out.println("See. It's me . Do-nothing start() ");
   }
   public static void main(String[] args) {
   	  MyThread myT = new MyThread();
   	  myT.start();
   }
}

1) When we use Thread class for creating Threads and when we call the current class object.start() , if we do not override the start method in the current class , Thread class start() will be executed and it will call current class's run() if it is present.

2)When we use Runnable for creating Thread we create a Thread object and pass current object reference as constructor argument.
After this if we call Thread object's start() , it will call Thread class start() which calls run in the current class if it is present.

       class MyThread extends Thread{
            public void run() {.... } 
            public static void main(String[] args) {
                     MyThread myT = new MyThread();
                     myT.start();
            }
       }

For the 2nd case

       class Test {
            public static void main(String[] args) {
                     Runnable rc = new RunnableClass();
                     Thread myT = new Thread(rc);
                     myT.start(); //See here
            }
       }
       class RunnableClass implements Runnable {
           public void run() {....}
       }

For the 3rd case
Also note that there is one more constructor for Thread. Which is a plain do-nothing thread.like the foll. When you call myT.start() for this case, it calls the plain do-nothin run() method in the Thread class and nothing is happens due to this started thread.

       class Test {
            public static void main(String[] args) {
                     Runnable rc = new RunnableClass();
                     Thread myT = new Thread();//Do nothing thread
                     myT.start(); //See here
            }
       }

regds
maha anna