gestione di errore in java: return null o exception?

è meglio gestire gli errori con dei valori di ritorno dove possibile o scatenare eccezioni? dal punto di vista della leggibilità del codice non c’è dubbio che le eccezioni siano una soluzione pulita e ottimale, ma dal punto di vista delle performance come impattano sull’esecuzione?

ho fatto una prova scrivendo due programmi molto semplici che chiamano ricorsivamente una funzione un numero di volte specificato da riga di comando e poi escono in errore. il primo programma gestisce l’errore restituendo null, il secondo scatena un’eccezione

a seguire i due codici


/** gestione errore con null */
class JavaNull{
public static void main(String[] arg){
JavaNull j=new JavaNull();
Object o=j.error(Integer.parseInt(arg[0]));
if(o!=null)
System.out.println("do stuff");
else
System.out.println("o was null");
}
Object error(int deep){
//se ho raggiunto la profondità richiesta
//restituisco la condizione di errore
if(deep==0)
return null;
//ricorsione e test del valore di ritorno
if(error(deep-1)!=null){
System.out.println("do stuff");
return new Object();
}
else
return null;
}
}


e il secondo codice


/** gestione dell'errore con eccezione*/
class JavaExc{
public static void main(String[] arg){
JavaExc j=new JavaExc();
try{
Object o=j.error(Integer.parseInt(arg[0]));
System.out.println("do stuff");
}catch(Exception e){
System.out.println(e.getMessage());
}
}
Object error(int deep) throws Exception{
//raggiunta la profondità richiesta
//scateno l'eccezione
if(deep==0)
throw new Exception("o was null");
//altrimenti procedo di ricorsione
error(deep-1);
return new Object();
}
}


la versione di java e di javac usata e’ 1.5.0_11 originale sun

sono stati lanciati con opzioni 0, 10, 20 e 30 per variare la profondità della ricorsione e ogni lancio è stato ripetuto tre volte facendo poi media dei valori. ogni report di dati per ogni riga ha prima il dato con la gestione di errore a null e poi con lancio di eccezione.


profondità 0
real 179,33 148,33 -17,29%
user 78,67 73,33 -6,78%
sys 10,67 16 50,00%

profondità 10
real 207 155,33 -24,96%
user 78,67 84 6,78%
sys 14,67 16 9,09%

profondità 20
real 178,33 189,33 6,17%
user 92 93,33 1,45%
sys 12 18,67 55,56%

profondità 30
real 173 153,33 -11,37%
user 76 76 0,00%
sys 18,67 14,67 -21,43%


il risultato complessivo mediando i valori e facendo il rapporto tra metodo eccezione e metodo null è:

real -11,86%
user +0,36%
sys +23,30%


i valori interessanti per l’esperimento sono user (tempo in userspace) e sys (tempo in kernel space): è evidente che l’uso di eccezioni aumenti sensibilmente quest’ultimo. usando le eccezioni si ha quindi un peggioramento delle performance ottenendo in cambio il vantaggio di una gestione degli errori più pulita e mantenibile. è il solito problema di vantaggi/costo…

segnalo un articolo su javaworld: exceptions in java: nothing exceptional about them