Re: Exception Names
Tom Anderson wrote:
For once, i [sic] think i [sic] might agree with the anti-checked-exception crowd here.
InterruptedException is almost universally misunderstood, and almost
universally dealt with by catch-and-forget. This is exactly the wrong
thing to do with it, but people do it because they're scared to let it
pass, or do what it takes to terminate their method early. The reason
they do it is that the compiler won't let them ignore it. It screams at
them until they throw or catch,
Making it a runtime exception to suit bad programmers is a bad solution. Make
programmers learn their job; that's the right solution.
If it was a RuntimeException, the compiler wouldn't bother them, they'd
ignore it, and they'd effectively default to letting it pass, like
Which isn't really the right thing to do.
declaring it as a throws would do now. And that means that all their
methods would respond to interrupts by immediately stopping and
terminating, which is probably the right behaviour in most cases (and if
Probably not. The point is to let the thread gracefully handle being
interrupted, which is unlikely to happen with an immediate stop and termination.
they're using finally blocks right, it might even happen cleanly). Code
But now you're talking about responsible programmers, who presumably will
learn the proper care and feeding of InterruptedException and won't mind that
it's a checked exception.
which cared about interruption - the code which is expecting control to
return to it after interruption - could still catch it. Problem more or
less solved.
Lew wrote:
People would have learned the hard way that they were getting the
exception, then still handled it incorrectly.
Tom:
Except most of the time, they wouldn't be getting it, i [sic] reckon.
Interruption isn't something that just happens, it happens when code
farther out has interrupted the code that's running, and in that case,
rapid transfer of control to that code is exactly the right thing to do.
After, of course, gracefully handling whatever the interrupted thread has to
handle. For example, as Mr. Goetz recommends, it probably has to call
'Thread.currentThread().interrupt()' before moving on.
I swan the exception has to be handled, so making it checked is not so harmful.
--
Lew
http://www.merriam-webster.com/dictionary/swan[3]