I know there are two ways to use a thread in java:
I also know implementing Runable is better than extending Thread.
But why there are two ways - why not only one?
If implementing Runnable is a better approach, why is there another option?
What would be wrong with having only one option ?
extends Thread:
your thread creates unique object and associate with it
implements Runnable:
it shares the same object to multiple threads
Another thing to note, since you can extend only one class in Java, if you extends Thread, you can't extend another class. If you choose to implement Runnable, you can extend class then.
Technically, there is only one way: implement Runnable. Thread, incidentally, does just that, so extending it you trivially satisfy the interface requirement.
Just another reason why we use each type of threading.
Extending Thread class will not give you an option to extend any other class. But if you implement Runnable interface you could extend other classes in your class..
So depending on your design requirement you could use either of the menthods.
Subclassing Thread class allows you to modify other overridable functions of the Thread class, should you wish to do so. You, probably, shouldn't.
Also, subclassing Thread class can result in a more readable code sometimes where in your subclass you can have your own custom API. One can imagine classes such as DownloadingThread, RenderingThread etc extending Thread.
Using Thread as a task provides a compact way to create and run a parallel thread
new Thread() {
public void run() {
...
}
}.start();
Both methods have different approaches. Implementing Runnable interface does not give any control over thread itself.And if we extends thread class then derived class can not extend any other base class.
So if user wants fully control over program then Extending of Thread class is better option and if user wants flexibility of extending other base classes then Implementing Runnable Interface is good option.
Even if you implement Runnable interface you will need to create thread to let your task run as a thread. obvious advantages you get out implementing Runnable are
Extending Thread class is just an option as it implements Runnable internally so you end up implementing Runnable interface indirectly. Its just that this class was not made final to prevent developers from extending it. As Joshua Bloch mentions in 'Effective Java' that there should be no reason to extend Thread usually
By extending Thread, each of your threads has a unique object associated with it, whereas implementing Runnable, many threads can share the same runnable instance.
Most of the time, we use runnable interface. Because that allows us more flexible on the structure and functionality. Java allows multiple inheritance for interface. That concept is used quite a lot in Software Design.
By the way, there is another interface called callable. A callable class could return value in type V and also may throw checked exceptions.
When we create thread by implements runnable we don't initialize any value during thread creation. But when we extend Thread class to create thread we can initialize some value if needed using the advantage of constructor as follw
public class MyThread extends Thread
{
int aValue;
public Mythread(int aValue)
{
this.aValue = aValue;
}
............................
............................
}
When we create thread we can initialize as follow
MyThread t = new MyThread(7);
t.start();
Beside that since java doesn't support Multiple inheritance so we if extends Thread class then we lost our opportunity to extends another class.Hence in this scenario runnable interface is so helpful for creating thread
