Creating Thread Using Runnable Interface in Java Example

Another way to create a thread in Java is to define a class that implements the Runnable interface. The previous technique of creating threads by extending the Thread class does not work when you want a class that extends another class and can also run as a thread. It is because java supports only single inheritance, i.e., does not allow a class to extend more than one class. So in such a case implement the Runnable interface. The Runnable interface declares only one method run () that contains the code executed when the thread started. Therefore, if you define a class that implements the Runnable interface, then it must implement the run () method.

The Runnable interface commonly used when you add multithreading support to applets for animation or other purposes. It is required because the Applet class already extends java.applet.Applet class and it not possible to extend the Thread class.

Now let us consider a class MyThread that implements the Runnable interface.

class MyThread implements Runnable {
private int threadId;
     private int delay;
MyThread(int id,int d){
threadId=id;

        delay = d;//time for which thread sleeps
}
    public void run(){
for(int i = 0;i<5;i++){
System.out.println(“Thread “+ threadId +” is running”);
try{
               Thread.sleep(delay);
}
            catch(InterruptedException e){
e.printStackTrace();
            }
        }
           System.out.println(“Thread “+ threadId +” is Finished”);
    }
}

The MyThread class consists of two fields threadId and delay both of type into The threadId field is used to assign a thread number to a thread and delay field is used to give time for which the thread sleeps. It also contains a parameterized constructor that contains two parameters id and d both of type into this constructor sets the value for the threadId and delay field.
The run () method of the Runnable interface implemented. This method contains the code executed when the calling thread starts execution. This method contains the code similar to the one discussed earlier in the previous example.
After creating the MyThread class, create a Runnable instance of the defines class. The statement
MyThread r1 = new MyThread(1,500);
OR Runnable r1 = new MyThread(1,500);
creates a Runnable instance of the Mythread class and assigns an appropriate value to its fields using MyThreadclass constructor.
Now create an object of the Thread class by passing your class’s instance (i.e., r1) to the
Thread (Runnable target) constructor. This object is your Thread object. The following statement performs the task.
Thread t1 = new Thread(r1);
You can also combine the creation of Runnable instance as well as an object of the Thread class in a single statement as follows,
Thread t1 = new Thread(new MyThread(1,500));
The purpose of invoking the Thread (Runnable target) constructor is to connect the Runnable object to the Thread API that allows the API to identify the location of the run () method when a thread starts.
As you know that the new thread does not begin execution until its start () method is invoked, so invoke the start () method on your Thread object using the following statement
t1.start () ;
The complete program is as follows,

class MyThread implements Runnable {
private int threadId;
    private int delay;
MyThread(int id,int d){
threadId = id;
delay = d;//time for which thread sleeps
    }

     public void run(){
         for(int i=0;i<5;i++){
            System.out.println(“Thread “+ threadId +” is running”);
try{

               Thread.sleep(delay);
            }
            catch(InterruptedException e){
e.printStackTrace();
}
        }
        System.out.println(“Thread “+ threadId +” is Finished”);
}
}
public class RunnableThread {
    public static void main(String[] args){
        System.out.println(“Main thread starts”);
MyThread r1 = new MyThread(1,500);
MyThread r2 = new MyThread(2,300);
MyThread r3 = new MyThread(3,600);
        Thread t1 = newThread(r1);
Thread t2 = newThread(r2);
        Thread t3 = newThread(r3);
t1.start();
t2.start();
t3.start();
        System.out.println(“Main thread is finished”);
}
}

From the above discussion, we conclude that defining, instantiating and starting a new thread using a Runnable interface involves the following steps.
1. Define the class that implements the Runnable interface and implement the run () method of the Runnable interface in the class.
2. Create an instance of the defined class.
3. Create an instance of the Thread class using the Thread (Runnable target) constructor.
4. Start the thread by invoking the start () method on your Thread object.