Thread using extending Thread class

Extending the Thread Class

The thread class can be extended to create the thread. A typical procedure for doing this is as follows
1.      A class extending the Thread class overrides the run() method from the Thread class to define the code executed by the thread.
2.      This subclass may call a Thread constructor explicitly in its constructors to initialize the thread, using the super() call.
3.      The start() method inherited from the Thread class is invoked on the object of the class to make the thread eligible for running.


class A extends Thread{
    public void run(){
        say();
    }
    public void say(){
        for(int i=0;i<10;i++){
            try{Thread.sleep(500);}catch(Exception e){}
            System.out.println("Hello "+i+" times");
        }
    }
}
class B extends Thread{
    public void run(){
        say();
    }
    public void say(){
        for(int i=0;i<10;i++){
            try{Thread.sleep(500);}catch(Exception e){}
            System.out.println("Hi "+i+" times");
        }
    }
}



class ThreadDemo1{
    public static void main(String ar[]){
        A a1=new A();
        B b1=new B();
        //a1.run();
        //b1.run();
        a1.start();
        b1.start();
    }
}



When creating threads, using Thread class there are two Disadvantages
·         Extending the Thread class means that the subclass cannot extend any other class, whereas a class implementing the Runnable interface has this option.
·         A class might only be interested in being runnable, and therefore, inheriting the full overhead of the Thread class would be excessive.

Thread Creation using Runnable interface




In java programming there are something predefined which is used to create a thread. The thread in java represent by the Object of your class which has the Thread property. So when you create a thread you have to just put some extended properties in your class due to which the behavior of Object of your class is like the thread.

There are two ways to create a thread.
  • First is , Implements Runnable interface in to your class, and defined run method declared by it
  • Second is Extends Thread class in to your class and override the run method.

Runnable interface

Runnable interface comes from java.lang package. Runnable interface has only one method declaired as follow

public interface Runnable
{
     public void run();
}
So to make a thread using the Runnable interface you have to define the run method. The run method is necessary to be thread of a normal class.
A thread, which is created based on an object that implements the Runnable interface, will execute the code defined in the public method run(). In other words, the code in the run() method defines an independent path of execution and thereby the entry and the exits for the thread. The thread ends when the run() method ends, either by normal completion or by throwing an uncaught exception.
The steps for creating threads using Runnable interface is as follows:
1.      A class implements the Runnable interface, providing the run() method that will be executed by the thread. An object of this class is a Runnable object.
2.      An object of Thread class is created by passing a Runnable object as argument to the Thread constructor. The Thread object now has a Runnable object that implements the run() method.
3.      The start() method is invoked on the Thread object created in the previous step. The start() method returns immediately after a thread has been spawned.

class A implements Runnable{
    public void run(){
        say();
    }
    public void say(){
        for(int i=0;i<10;i++){
            try{Thread.sleep(500);}catch(Exception e){}
            System.out.println("Hello "+i+" times");
        }
    }
}
class B implements Runnable{
    public void run(){
        say();
    }
    public void say(){
        for(int i=0;i<10;i++){
            try{Thread.sleep(500);}catch(Exception e){}
            System.out.println("Hi "+i+" times");
        }
    }
}





class ThreadDemo1{
    public static void main(String ar[]){
        A a1=new A();
        B b1=new B();
        Thread t1=new Thread(a1);
        Thread t2=new Thread(b1);
        t1.start();
        t2.start();
    }
}

Popular Posts