Re: Avoid creating a stacktrace prior to JDK 1.7
On 10/1/2011 4:04 PM, Jan Burse wrote:
Lew schrieb:
- Rules were made to be broken.
Yes, a well known common place.
Now back to the original question of my
post, I was giving the ClassNotFoundException
only as a motivation, can I suppress the
fetching of the backtrace in a Java
Exception object prior to JDK 1.7?
Quoth the Java SE 6 Javadoc: "A throwable [sic] contains a
snapshot of the execution stack of its thread at the time it was
created." That is, the Javadoc promises that a Throwable carries
a stack trace. A Throwable with no stack trace breaches the
promise, and since that promise was still in force as of 1.6 I
deduce that there's no such thing as a stackless Throwable in that
version, or that it's a bug if there is.
However, it's the trace of the stack that *creates* the
Throwable, not necessarily that of the stack that *throws* it.
So you could create a Throwable once and throw it as many times
from as many different contexts as you like:
class MasochismInAction {
private static OriginUnknownException mystery =
new OriginUnknownException("Ha-ha, can't find me!");
public void foolMeOnce() throws OriginUnknownException {
if (iFeelLikeIt) {
throw mystery;
}
}
public void foolMeTwice() throws OriginUnknownException {
if (Math.random() < 0.3) {
throw mystery;
}
}
...
}
.... and there you have it: Exceptions without (most of) the expense
of filling a stack trace. Also, it must be noted, Exceptions with
less ability to help in debugging than almost any others. ("Almost"
because I've heard somewhere that the JVM creates a few Throwables
like VirtualMachineError in advance, because by the time they're
needed the JVM can no longer trust itself to fill them in properly.)
Personally, I think "Don't Do That" is sage advice here.
--
Eric Sosman
esosman@ieee-dot-org.invalid