Java Create Threads

Java Create Threads

2. Creating a thread by implementing Runnable interface

Now, we write another program, with the same functionality (printing 0 to 9 with an interval of 1000 milliseconds), but implementing Runnable interface instead of the earlier Thread class.

public class Demo implements Runnable     		  
{
  public void run()        
  {
    try  
    {
      for(int i=0; i<10; i++)    
      {
	System.out.println("Welcome to threads: " + i);    
        Thread.sleep(1000);        
      }                                       
    }          
    catch(InterruptedException e)  
    {  
      System.err.println("Sleep time is disturbed, you may get incorrect functionality.  " + e);
    }
    System.out.println("Successful");   
  }
  public static void main(String args[])    
  {
    Demo d1 = new Demo();
    Thread t1 = new Thread(d1);
    t1.start();              
  }
}

In the above program, the object, d1, is not implicitly a thread because it is not extending Thread class; but implements Runnable interface. It takes one more statement to get the run() method executed.

Demo d1 = new Demo();
Thread t1 = new Thread(d1);
t1.start();

Create an object, t1, of Thread class and pass the d1 object as parameter. Then, start the thread t1 with start() method. It indirectly calls the run() method of Demo class. This is extra work when Runnable interface is implemented instead of extending Thread class.

Java Create Threads: Extends vs Implements

When to use Thread or when to prefer Runnable. Even though no difference exists in the output, there is a reason and necessity to implement Runnable interface in some cases. If your class already extends another class like Frame or Applet, you cannot extend Thread class as Java does not support multiple inheritance. To overcome this problem, designers introduced another style of implementing Runnable interface. If your class does not extend another class, you can go for Thread class.

Java Create Threads: Why implementing Runnable approach is better than Thread extending?

In general, not exactly pertaining threads, when a method is called by an object, the JRE checks for overloaded methods exist or not, super class method is overridden or not (especially when a subclass object is assigned to super class object or reference variable) etc. It may be the same case with run() method of Thread class. If you implement Runnnable, JRE checks run() is implemented or not but does not check all the other round about rules. For this reason, everyone says implementing Runnable is speedier than Thread extends.