Re: Why does Java require the throws clause? Good or bad language design? (fwd)
"Robbert Haarman" <comp.lang.misc@inglorion.net> wrote in message
news:20070221060137.GZ3715@morgenes.shire.sytes.net...
On Wed, Feb 21, 2007 at 04:04:27AM +0000, Karl Uppiano wrote:
And another thing: I always wished they had made InterruptedException a
RuntimeException. Hardly anyone cares about that exception, and most of
the
time, when someone wants a thread to sleep or wait, they just eat
InterruptedException in an empty catch block, which is just wrong.
Doesn't the exception (also) signal that Thread.sleep (or whatever) did
not sleep for the whole interval that was specified? In that case,
simply catching and ignoring it is not enough.
The main reason for the InterruptedException is that someone might interrupt
the thread, wanting it back, or wanting it to end. The person holding the
reference to the thread might not be the person making it wait. By catching
and eating the InterruptedException, they can prevent the thread from
returning control to the person interrupting it, which is probably not the
desired behavior. If it were a RuntimeException, they would not be compelled
to handle the exception, but the person interrupting the thread would expect
it, and be prepared to deal with it. They'd have to catch it so that the
thread would not die, or they could let it fly, and the system would kill
the thread, which might be exactly what they want.
I often wrap it in a RuntimeException and throw that instead, so
higher-ups can deal with it without every layer having to declare it
or catch it.
Wouldn't it abort the program if the exception isn't caught and handled?
Only that thread would die, unless it was the or only thread in the
application. Usually, though, it is *me* catching the exception way up in
the vicinity of main(), and doing something specific with it.
I wonder how many unnecessary lines of code have been
written to deal with InterruptedException.
What should have happened (and I think it must have happened, too), is
the implementation of wrappers that make the exception go away. E.g., in
case of Thread.sleep, the wrapper would sleep for the specified amount
of time, regardless of how many times the actual Thread.sleep got
interrupted.
That was not the intent of InterruptedException. It was really intended as a
way to forcibly break out of a wait. The exception provides a good way to
detect that condition. I only wish it were a RuntimeException, so that if I
don't expect it (e.g., I have the only reference to the thread and I'm
making it wait, therefore it cannot be interrupted by anyone else), I would
not have to explicitly handle it, because it should never happen.
Regards,
Bob
--
You are in a maze of twisted little characters, all different.
-- Me, while learning Chinese