Why is Thread not an abstract class and start() not final?

Question

Why was the Thread class implemented as a regular class and not an abstract class with run() method being abstract.

Will it po

Answer 1

I feel a few calirifcations should be posted for the answers :

"Are you sure you would never want to override it?"

No ! I would not. Thats like saying, "Are you sure , you want to declare this variable private?" Because if I could declare any variable I use as public without fearing that other developers may mess my design logic, coding would be a breeze. One of the most important purpose of OOPS concepts of Scope, abstraction, polymorphism, Error handling etc is to communicate to other developers the design and intentions behind your code.As pointed out in the question, when you override start method, nobody is forcing you to use super.start(). @Codebender wrote a start method for a thread without using super.start() and compiler never complained. So he is free to break the whole mechanism of Threading and compiler is suppose to just let it pass? Thread's start method ensures that run method is called and execute at the right time ! It is critical to the very concept of Threading. I would be more than happy to be corrected, if I missed something here. 2.

Because the recommended way to create a start a thread is not to subclass Thread.

OK, if codebender is allowed by design, to sublass Thread and mess up the start method, By that logic, it is the design shooting itself in the foot. By another statement made,(which I agree with completely) , Runnable is the recommended way. Then why do we allow Thread class at all to instantiate the thread at all with no restrictions? This is followed by :

You can't replace the implementation of start() by your own implementation,

That actually supports codebender's claim that start method should be final when you say that.. ^

The one point, that's valid, is mentioned already as a side note, but is the actual answer to this question

"Backward compatibility".

In fact, improvements were even going on as late as JDK 5.0 , when they incorporated many major additions and clarifications to the Java concurrency model. We want backward compatibility to be supported all the way and thats why Thread class is still exactly as it was before, even though Runnable interface is the recommended way nowadays.

Again, I would be more than happy to be corrected, if I missed something.