Scenario where extending thread is preferred than implement Runnable? [duplicate]

Question 1

You should extend a Thread as much as you extend other library classes.

Take a List for example, more specifically ArrayList, you could add extra behaviour on it, like rejecting a value when adding if a certain predicate fails.
Then you can call that an PredicatedArrayList.

It is still a debate whether you want to extend ArrayList here or not, but that debate is not up for this question.

So an example of extending a thread would be a thread that kills itself after a specific amount of time. Then you would have SuicidingThread extends Thread, which could have a constructor taking the time.

This even fortifies the argument that you should put your actual tasks in a Runnable.
Like Runnable somethingRunnable = new SomeClass();, where SomeClass implements Runnable.

Now you can do either:

Thread someThread = new Thread(somethingRunnable);
Thread someThread = new SuicidingThread(somethingRunnable, 5, TimeUnit.DAYS);

So this would be an usecase for extending thread.

Question 2

Specializing means, extend the functionality of existing Thread class. It could be anything depending on the application requirement. The one I've mentioned below may not be true logically.

public class MyThread extends Thread{
@Override
public void interrupt() {
    if(thread has started some operation on database){
        //roll back transaction
    }
    super.interrupt();
}
}

Here before interrupting the thread, we can check if any database operation is running currently and roll back it. Though it can be done from the interrupted catch block, handling it from extended class reduce the number of lines if you create lots of instances of this thread at different places in the application. It's just an example, nobody will use it this way. :)

Question 3

Because java does not support for multi-inheritance. If you have a class named Person.

class Person{
 String name;
 int age;
}

Then you want to create a class Man which extends Person

class Man extends Person{

}

Now you have used the extends keyword to declare that Man is a Person. Then if you want a Man to be performed like a thread,you can not extend Thread again because Java do not support for multi-inheritance.So just use Runnable interface which can be implements together with other interfaces.

class Man extends Person implements Runnable{
  public void run()[
  }
}

EDIT: "extends thread only when you are specialising Thread's behaviour" means that your class is only a Thread which does not have other features,because when your class contains other features,you need to extends other super classed rather then the Thread class.As I have mentioned before,java does not support for multi-inheritance,so just extends thread only when you are specialising Thread's behaviour.

Question 4

Java doesn't support multiple inheritance, which means you can only extend one class in Java so once you extended Thread class you lost your chance and can not extend or inherit another class in Java so this class is specialized for Thread only.

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.

Extending a class generally means adding new functionality, modifying or improving behaviors. If we are not making any modification on Thread then use Runnable interface instead.

Thread class has some behavior decided by JDK developers when you want to make some modification to it then you can extend your class with Thread class and modify it.

Question 5

There are several reasons for preferring Runnable implementation over Thread extension:

Always prefer composition over inheritance and you will end up with less coupled code. One way to decide how your class is related to Thread is to check the "is a" relation vs a "has a".
In practice extending Thread will force you to create new instances instances of your class for each thread, instead of sharing the same instance in the case of Runnable. See this.
Java supports only single inheritance

One example of legit use cases for extending Thread is when you need to design a Thread class with custom properties (ex: caching resources) that is being part of a CachedThreadPool