Question

I know that going into a catch block has some significance cost when executing a program, however, I was wondering if entering a try{} block also had any impact so I started looking for an answer in google with many opinions, but no benchmarking at all. Some answers I found were:

1. Java try/catch performance, is it recommended to keep what is inside the try clause to a minimum?
2. Try Catch Performance Java
3. Java try catch blocks

However they didn’t answer my question with facts, so I decided to try it for myself.

Here’s what I did. I have a csv file with this format:

host;ip;number;date;status;email;uid;name;lastname;promo_code;

where everything after status is optional and will not even have the corresponding ; , so when parsing a validation has to be done to see if the value is there, here’s where the try/catch issue came to my mind.

The current code that I inherited in my company does this:

StringTokenizer st=new StringTokenizer(line,";");  
String host = st.nextToken();
String ip = st.nextToken();
String number = st.nextToken();
String date = st.nextToken();
String status = st.nextToken();                             
String email = "";
try{
    email = st.nextToken();
}catch(NoSuchElementException e){
    email = "";
}

and it repeats what it’s done for email with uid, name, lastname and promo_code.

and I changed everything to:

if(st.hasMoreTokens()){
    email = st.nextToken();
}

and in fact it performs faster. When parsing a file that doesn’t have the optional columns. Here are the average times:

 --- Trying:122 milliseconds
 --- Checking:33 milliseconds

however, here’s what confused me and the reason I’m asking: When running the example with values for the optional columns in all 8000 lines of the CSV, the if() version still performs better than the try/catch version, so my question is

Does really the try block does not have any performance impact on my code?

The average times for this example are:

--- Trying:105 milliseconds
--- Checking:43 milliseconds

Can somebody explain what’s going on here?

Thanks a lot

Answer 1

Yes, try (in Java) does not have any performance impact. The compiler generates no VM statements for a try block. It simply records the program counters between which the try block is active and attaches this information to the method in the class file. Then, when an exception is thrown, the VM unwinds the stack and checks at each frame whether the program counter in that frame is in a relevant try block. This (together with building the stack trace) is quite costly, so catching is expensive. However, trying is free :).

Still, it is not good practice to use exceptions for regular control flow.

The reason why your code performs faster is probably that catching is so extremely costly that it outweights the time saved by replacing the check by a simple try.

Try catch can be faster in code where the catch is triggered not very often, e.g., if you go into the try 10000 times but only catch once, the try method would be faster than the if-check. Still, this is no good style and your way of explicitly checking for more tokens is to be preferred.