Re: Why can't I start a thread twice?
The rule is pretty simple: the abstraction for "task" is Runnable, not
Thread; the abstraction for "worker" is Thread.
So, if you are implementing a *task* (which is almost always the
case), implement it as a Runnable. If you are implementing a task-
management framework (and why would you, when JUC provides an
excellent one), only then is it reasonable to extend Thread.
The confusion comes around from the notion that when you are writing a
toy sample program, Thread seems more convenient for illustrating what
is going on (e.g., there's a "writer thread" and a "reader thread"),
so many examples
in books use that approach -- and that colors the student's
thinking.
It is usually better to implement 'Runnable' and pass it to a 'Threa=
d'
than to extend 'Thread'.
Not much better, but better.
Why?
"implements Runnable" allows the class to extend another class
while "extends Thread" does not.
If you are confident that you class will not need to extend
another class later, then you don't care.
Though, whether a person "cares" depends on certain preferences. It'=
s
true that if you're sure the class won't need to extend another class,
there is no quantifiable reason to prefer one or the other. However,=
as
a personal preference, I prefer to only inherit a class if there's
actually a specific positive reason in favor of that. That "specific
positive reasons" is almost always about inheriting implementation, and
in the case of the Thread class, there's not really anything in the
implementation that needs inheriting. You can use the Thread class
as-is without further complication and with equivalent facility even
without inheriting from it.
OK, this point was known to me (I expected a technical difference).
In this particular simple example, my class is free to inherit Thread
or implement Interface. In matter of taste, I was also told to use
inheritance, only if there is an is-relationship between the two
classes. In my view, since my class needs a to run something in
paralled does not make it a _Thread_. It is still a moving object
for example. Any way, it looks like even the expers differ on this
matter.
In addition to all that, I'll point out that you can "implement
'Runnable'" simply by providing an anonymous class. In many cases, t=
his
is as simple as this:
Thread thread = new Thread(
new Runnable()
{
public void run()
{
threadMethod();
}
});
Where "threadMethod()" is a method defined in the current class
containing the actual code for the thread.
That is too much for the introductory level we have. Thanks for
the hint anyway.
Cya
Chuan.- Hide quoted text -
- Show quoted text -