Is it more efficient to cast twice or create new instance

Question

Consider these 2 pieces of code (you can assume execeptionObj is of type Object, but we know it's an instance of Throwable):

1)

logger.log(Level.ERROR, (Throwable) exceptionObj,
    ((Throwable) exceptionObj).getMessage());

2)

Throwable t = new Throwable((Throwable)exceptionObj);
logger.log(Level.ERROR, t, t.getMessage());

During a code review for a project I'm working on, one reviewer is saying that the first way is not as efficient as the second way because it involves 2 casts. I just wondered what you thought. It seems like creating a new instance would involve some overhead as well.

Answer 1

Given the cost of an exception and merely of printing out the contents, I would suggest this debate is somewhat specious.

Answer 2

The two pieces of code do different things. In the second, you are no longer passing exceptionObj, but "an unspecified Throwable caused by exceptionObj". I don't think that's what you want.

Did you mean the first line of the second one to be:

Throwable t = (Throwable) exceptionObj;

It is very marginally more efficient, I'd guess, but would not let this decide the issue. Which is more readable is the key, and I think the (modified) second one is more readable.

Do you really have to case to Throwable? surely the logger takes a Throwable already?

Answer 3

1. you will notice very little to no performance difference between the two. Especially since it is exception handling code that will most likely not run in a tight loop
2. Example 2 only compiles when exceptionObj is either a String or a Throwable. If it's a String, then the first example would not compile at all, if it's a Throwable, then your casts are unnecessary in the first example
3. creating a new Throwable just to avoid casts is a terrible thing, because it changes what your code actually does.

Answer 4

Throwable t = (Throwable) exceptionObj;
logger.log(Level.ERROR, t, t.getMessage());

Answer 5

Why not cast once and use twice?

Throwable t = (Throwable) exceptionObj;

It'll be difficult to tell the actual answer without profiling and using heavy load.

Answer 6

logger.log(Level.ERROR, (Throwable) exceptionObj,
    ((Throwable) exceptionObj).getMessage());

This in theory will incur the cost of two type casts. In practice, the JIT compiler is may well optimize this to native code that performs only one typecast.

Throwable t = new Throwable((Throwable)exceptionObj);
logger.log(Level.ERROR, t, t.getMessage());

Here we replace two typecasts with one typecast and an object creation. However, the object that is created is a Throwable, and if you look at the constructor for Throwable you will notice that it calls fillInStackTrace(). This method creates a bunch of other objects to record information about the stack, and that is likely to be a lot more expensive than performing a (successful) type cast. Besides, there is a good chance that that typecast will have been optimized away.

Obviously, a thorough investigation would entail profiling the two versions of the code and examining the native code generated by the JIT compiler ...

(And as others have noted, the effect of the two pieces of code are different. The first one logs the original exception, and the second one logs a new Throwable with the original exception as a nested exception.)