Java Multithreading : how does thread creation with Runnable interface work?

Question

Could someone explain what does this code does? new Thread(new X()).start();

Rest of the code:

class X implements Runnable {
    X() {}
    }
    public static void main(String[] arg) {
        new Thread(new X()).start();
    }
}

Answer 1

This is a very simple example, which shows how to create a new thread and run it. When you create new threads in Java, you give them something to do - a "Runnable".

class X implements Runnable

This interface has only one method - run(). So you create a new thread, with a runnable in its' constructor.

new Thread(new X())

Once you have created a new thread, you have to start it with the start() method. This is when it calls the runnable's run() method. In your example, this has just been chained on after the construction of the thread:

new Thread(new X()).start();

Now, this example is unusual in that class X doesn't actually implement the run method. But normally, there's that extra bit, so your example would look like this:

class X implements Runnable {
    public void run() {
        System.out.println("This is running on a different thread!");
    }

    public static void main(String[] arg) {
        new Thread(new X()).start();
    }
}

Answer 2

You don't need to define a constructor if it's blank, first of all. It'll automatically be blank if you don't define one. Second of all, you can simply do an anonymous class definition, which I'll explain in a second. The method isn't main in this case, it's run. You can define a thread object using the anonymous class definition, too.

new Thread() {
    @Override
    public void run() {
        //Code here
    }
}.start();

The anonymous class definition allows you to define and instantiate a class which extends/implements another class both at the same time without actually creating the class. Also, note that X.main() is static, meaning that any instance of X will not have that method. You want to override run and call start. Start is just a method which calls run in a different thread. Note that you can't start a thread twice.

Answer 3

Every thread object has a method run(). if you call the start() method of thread object, then it will execute run().

The only difference is it will be executed separately/parallely and won't be in the existing sequence of operation.

Answer 4

You can create thread in two ways : one by extending Thread and other by implementing Runnable interface.

If you are not extending the Thread class,your class object would not be treated as a thread object. So you have to explicitly create Thread class object.

Thread class will take Runnable class as parameter in constructor.

You are passing the object of your class X that implements Runnable to Thread constructor so that your class run() method will be executed from start() method of Thread.

You can create threads in two different ways. Have a look at oracle documentation about thread creation

An application that creates an instance of Thread must provide the code that will run in that thread. There are two ways to do this:

1. Provide a Runnable object. The Runnable interface defines a single method, run, meant to contain the code executed in the thread. The Runnable object is passed to the Thread constructor

   public class HelloRunnable implements Runnable {
   
       public void run() {
           System.out.println("Hello from a thread!");
       }
   
       public static void main(String args[]) {
           (new Thread(new HelloRunnable())).start();
       }
   }
   

2. Subclass Thread. The Thread class itself implements Runnable, though its run method does nothing. An application can subclass Thread, providing its own implementation of run

   public class HelloThread extends Thread {
   
       public void run() {
           System.out.println("Hello from a thread!");
       }
   
       public static void main(String args[]) {
           (new HelloThread()).start();
       }
   
   }