Performance of try/catch

Yesterday I had a discussion with my friend and he said that according to his opinion try/catch statement in java is very performance expensive. Indeed it is always recommended to check value prior using it instead of try to use and then catch exception if wrong value caused its throwing.

I decided to check this and tried several code samples. All functions accept int and return the argument multiplied by 2.
But there were the differences:

1. just calculate the value and return it (foo())
2. calculate the value into try block followed by catch block (tryCatch())
3. calculate the value into try block followed by finally block (tryFinally())
4. calculate the value into try block followed by catch and finally blocks (tryCatchFinally())
5. divide integer value by zero into try block followed by catch block that just returns -1 (tryThrowCatch())
6. divide integer value by zero into try block followed by catch block that re-throws it. Outer try/catch structure catches the secondary exception and returns -1 (tryThrowCatch1())
7. divide integer value by zero into try block followed by catch block that wraps thrown exception with another RuntimeException and re-throws it. Outer try/catch structure catches the secondary exception and returns -1 (tryThrowCatch2())

I ran each test 100,000,000 times in loop and measured elapsed time. Here are the results.

Test name	Elapsed time, ms
foo	46
tryCatch	45
tryFinally	45
tryCatchFinally	44
tryThrowCatch	133
tryThrowCatch1	139
tryThrowCatch2	62293

Analysis

1. try/catch/finally structure written in code itself does not cause any performance degradation
2. throwing and catching exception is 3 times more expensive than simple method call.
3. wrapping exception with another one and re-throwing it is really expensive. 

Conclusions

Catching exceptions itself does not have any performance penalty. Throwing exception is indeed expensive, so validation of values before using them is better not only from design but also from performance perspective. 

The important conclusion is that we should avoid using very common pattern in performance critical code:

try {

     // some code

} catch (ThisLayerException e) {

    throw new UpperLayerException(e);

}

This pattern helps us to use layer specific exceptions on each layer of our code. Exception thrown from lower layer can be wrapped many times that creates extremely long stack trace and causes serious performance degradation. Probably better approach is to extend our domain level exceptions from RuntimeException and wrap only checked exceptions and only once (like Spring does).

Source code

The source code can used here can be found on github.