extends vs runnable

Posted: July 20, 2012 in Java

Extend vs Runnable

     class     Extends   Thread

class Myclass Extends Thread

class Implements Runnable

class Myclass implements Runnable

Thread is class

Thread is a class that’s why

We have to use extends key word

Runnable is an interface

Runnable is an interface so we hv

use implements key word

Does not support the mltiinheritence

If you want to extend the Thread class then it will make your class unable to extend other classes as java is having single inheritance feature

class Mine extends Thread,HttpServlet

  Not possible in java

support the mltiinheritence

If you implement runnable interface, you can gain better object-oriented design and consistency and also avoid the single inheritance problems

class Mine implements Runnable

,Serializable extends HttpServlet

 

 Does not override the run() method to start() the thread. No compile and run time exceptions.

class Mine extends Thread{

public static void main(){

new Mine().start();

}

}

 should override (implements) the run() method otherwise it gives compile time error

class Mine implements Runnable{

public void run(){

System.out.println(“run”);

}

public static void main(){                                           Thread t = new Thread(new Mine());                                           t.start();

}

 

  each of your thread creates unique object and associate with it. (plz go through the below example to know the difference)  it shares the same object to multiple threads

(plz go through the below example to know the difference)

 

class ImplementsRunnable implements Runnable {

private int counter = 0;

public void run() {

counter++;

System.out.println(“ImplementsRunnable : Counter : ” + counter);

}

}

class ExtendsThread extends Thread {

private int counter = 0;

public void run() {

counter++;

System.out.println(“ExtendsThread : Counter : ” + counter);

}

}

public class ThreadVsRunnable {

public static void main(String args[]) throws Exception {

//Multiple threads share the same object.

ImplementsRunnable rc = new ImplementsRunnable();

Thread t1 = new Thread(rc);

t1.start();

Thread.sleep(1000); // Waiting for 1 second before starting next thread

Thread t2 = new Thread(rc);

t2.start();

Thread.sleep(1000); // Waiting for 1 second before starting next thread

Thread t3 = new Thread(rc);

t3.start();

//Creating new instance for every thread access.

ExtendsThread tc1 = new ExtendsThread();

tc1.start();

Thread.sleep(1000); // Waiting for 1 second before starting next thread

ExtendsThread tc2 = new ExtendsThread();

tc2.start();

Thread.sleep(1000); // Waiting for 1 second before starting next thread

ExtendsThread tc3 = new ExtendsThread();

tc3.start();

}

}

Output:

ImplementsRunnable : Counter : 1

ImplementsRunnable : Counter : 2

ImplementsRunnable : Counter : 3

ExtendsThread : Counter : 1

ExtendsThread : Counter : 1

ExtendsThread : Counter : 1

If you implement runnable interface, you can gain better object-oriented design and consistency and also avoid the single inheritance problems

each of your thread creates unique object and associate with it.

In the Runnable interface approach, only one instance of a class is being created and it has been shared by different threads. So the value of counter is incremented for each and every thread access.

Whereas, Thread class approach, you must have to create separate instance for every thread access. Hence different memory is allocated for every class instances and each has separate counter, the value remains same, which means no increment will happen because none of the object reference is same.

When to use Runnable?

Use Runnable interface when you want to access the same resource from the group of threads. Avoid using Thread class here, because multiple objects creation consumes more memory and it becomes a big performance overhead.

Apart from this, object oriented designs have some guidelines for better coding.

 

Coding to an interface rather than to implementation. This makes your software/application easier to extend. In other words, your code will work with all the interface’s subclasses, even ones that have not been created yet.

Interface inheritance (implements) is preferable – This makes your code is loosely coupling between classes/objects.(Note : Thread class internally implements the Runnable interface)

Example: coding to an interface.

Map subject = new HashMap();

Assigning HashMap object to interface Map,  suppose in future if you want to change HashMap to Hashtable or LinkedHashMap you can simple change in the declaration part is enough rather than to all the usage places. This point has been elaborately explained here.

Which one is best to use?

Ans : Very simple, based on your application requirements you will use this appropriately. But I would suggest, try to use interface inheritance i.e., implements Runnable.

 

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s