What's the difference between Thread start() a

Question

Say we have these two Runnables:

class R1 implements Runnable {
    public void run() { … }
    …
}

class R2 implements Runnable {
    public void run() { … }
    …
}

Then what's the difference between this:

public static void main() {
    R1 r1 = new R1();
    R2 r2 = new R2();

    r1.run();
    r2.run();
}

And this:

public static void main() {
    R1 r1 = new R1();
    R2 r2 = new R2();
    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);

    t1.start();
    t2.start();
}

Answer 1

The difference is that Thread.start() starts a thread that calls the run() method, while Runnable.run() just calls the run() method on the current thread.

Answer 2

The difference is that when program calls start() method, a new thread is created and code inside run() is executed in new thread while if you call run() method directly no new thread will be created and code inside run() will execute in the current thread directly.

Another difference between start() and run() in Java thread is that you can not call start() twice. Once started, second start() call will throw IllegalStateException in Java while you can call run() method several times since it's just an ordinary method.

Answer 3

Actually Thread.start() creates a new thread and have its own execution scenario.

Thread.start() calls the run() method asynchronously,which changes the state of new Thread to Runnable.

But Thread.run() does not create any new thread. Instead it execute the run method in the current running thread synchronously.

If you are using Thread.run() then you are not using the features of multi threading at all.

Answer 4

In the first case you are just invoking the run() method of the r1 and r2 objects.

In the second case you're actually creating 2 new Threads!

start() will call run() at some point!

Answer 5

Start() method call run override method of Thread extended class and Runnable implements interface.

But by calling run() it search for run method but if class implementing Runnable interface then it call run() override method of Runnable.

ex.:

`

public class Main1
{
A a=new A();
B b=new B();
a.run();//This call run() of Thread because run() of Thread only call when class 
        //implements with Runnable not when class extends Thread.
b.run();//This not run anything because no run method found in class B but it 
        //didn't show any error.

a.start();//this call run() of Thread
b.start();//this call run() of Thread
}

class A implements Runnable{
@Override
    public void run() {
            System.out.println("A ");
    }
}

class B extends Thread {

    @Override
    public void run() {
            System.out.println("B ");
    }
}

`

Answer 6

If you do run() in main method, the thread of main method will invoke the run method instead of the thread you require to run.

The start() method creates new thread and for which the run() method has to be done