Est-il coûteux d'utiliser des blocs try-catch même si une exception n'est jamais levée?

Nous savons qu'il est coûteux d'attraper des exceptions. Mais est-il également coûteux d'utiliser un bloc try-catch en Java même si une exception n'est jamais levée?

J'ai trouvé la question / réponse Stack Overflow Pourquoi les blocs d'essai sont-ils chers? , mais c'est pour .NET .

tryn'a presque aucun frais du tout. Au lieu de faire le travail de configuration tryau moment de l'exécution, les métadonnées du code sont structurées au moment de la compilation de sorte que lorsqu'une exception est levée, il effectue maintenant une opération relativement coûteuse consistant à remonter la pile et à voir s'il tryexiste des blocs qui pourraient intercepter cela. exception. Du point de vue d'un profane, trypeut tout aussi bien être gratuit. C'est en fait une exception qui vous coûte - mais à moins que vous ne lanciez des centaines ou des milliers d'exceptions, vous ne remarquerez toujours pas le coût.

trya quelques coûts mineurs associés. Java ne peut pas effectuer certaines optimisations sur le code d'un trybloc, ce qu'il ferait autrement. Par exemple, Java réorganise souvent les instructions dans une méthode pour la rendre plus rapide - mais Java doit également garantir que si une exception est levée, l'exécution de la méthode est observée comme si ses instructions, telles qu'écrites dans le code source, étaient exécutées dans l'ordre jusqu'à une ligne.

Parce que dans un trybloc une exception peut être levée (à n'importe quelle ligne du bloc try! Certaines exceptions sont levées de manière asynchrone, comme en appelant stopun Thread (qui est obsolète), et même en plus, OutOfMemoryError peut se produire presque n'importe où) et pourtant il peut être intercepté et le code continue à s'exécuter par la suite dans la même méthode, il est plus difficile de raisonner sur les optimisations qui peuvent être faites, donc elles sont moins susceptibles de se produire. (Quelqu'un devrait programmer le compilateur pour les faire, raisonner et garantir l'exactitude, etc. Ce serait une grande douleur pour quelque chose censé être «exceptionnel») Mais encore une fois, en pratique, vous ne remarquerez pas des choses comme ça.

Mesurons-le, d'accord?

public abstract class Benchmark {

    final String name;

    public Benchmark(String name) {
        this.name = name;
    }

    abstract int run(int iterations) throws Throwable;

    private BigDecimal time() {
        try {
            int nextI = 1;
            int i;
            long duration;
            do {
                i = nextI;
                long start = System.nanoTime();
                run(i);
                duration = System.nanoTime() - start;
                nextI = (i << 1) | 1;
            } while (duration < 100000000 && nextI > 0);
            return new BigDecimal((duration) * 1000 / i).movePointLeft(3);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public String toString() {
        return name + "\t" + time() + " ns";
    }

    public static void main(String[] args) throws Exception {
        Benchmark[] benchmarks = {
            new Benchmark("try") {
                @Override int run(int iterations) throws Throwable {
                    int x = 0;
                    for (int i = 0; i < iterations; i++) {
                        try {
                            x += i;
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    return x;
                }
            }, new Benchmark("no try") {
                @Override int run(int iterations) throws Throwable {
                    int x = 0;
                    for (int i = 0; i < iterations; i++) {
                        x += i;
                    }
                    return x;
                }
            }
        };
        for (Benchmark bm : benchmarks) {
            System.out.println(bm);
        }
    }
}

Sur mon ordinateur, cela imprime quelque chose comme:

try     0.598 ns
no try  0.601 ns

Au moins dans cet exemple trivial, l'instruction try n'a eu aucun impact mesurable sur les performances. N'hésitez pas à mesurer les plus complexes.

De manière générale, je recommande de ne pas s'inquiéter du coût des performances des constructions de langage tant que vous n'avez pas la preuve d'un problème de performances réel dans votre code. Ou comme Donald Knuth mis il: « l' optimisation prématurée est la racine de tous les maux ».

try/ catchpeut avoir un impact sur les performances. En effet, cela empêche JVM d'effectuer certaines optimisations. Joshua Bloch, dans «Effective Java», a déclaré ce qui suit:

• Placer du code dans un bloc try-catch inhibe certaines optimisations que les implémentations JVM modernes pourraient sinon effectuer.

Oui, comme les autres l'ont dit, un trybloc inhibe certaines optimisations sur les {}personnages qui l'entourent. En particulier, l'optimiseur doit supposer qu'une exception peut se produire à tout moment dans le bloc, il n'y a donc aucune garantie que les instructions seront exécutées.

Par exemple:

    try {
        int x = a + b * c * d;
        other stuff;
    }
    catch (something) {
        ....
    }
    int y = a + b * c * d;
    use y somehow;

Sans le try, la valeur calculée à attribuer xpourrait être enregistrée en tant que "sous-expression commune" et réutilisée pour être affectée y. Mais à cause de la, tryil n'y a aucune garantie que la première expression ait jamais été évaluée, donc l'expression doit être recalculée. Ce n'est généralement pas un gros problème dans le code «en ligne droite», mais cela peut être significatif dans une boucle.

Il convient de noter, cependant, que cela s'applique UNIQUEMENT au code JITCed. javac n'effectue qu'une quantité impressionnante d'optimisation, et il n'y a aucun coût pour l'interpréteur de bytecode pour entrer / quitter un trybloc. (Aucun bytecode n'est généré pour marquer les limites du bloc.)

Et pour les meilleurs:

public class TryFinally {
    public static void main(String[] argv) throws Throwable {
        try {
            throw new Throwable();
        }
        finally {
            System.out.println("Finally!");
        }
    }
}

Production:

C:\JavaTools>java TryFinally
Finally!
Exception in thread "main" java.lang.Throwable
        at TryFinally.main(TryFinally.java:4)

sortie javap:

C:\JavaTools>javap -c TryFinally.class
Compiled from "TryFinally.java"
public class TryFinally {
  public TryFinally();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]) throws java.lang.Throwable;
    Code:
       0: new           #2                  // class java/lang/Throwable
       3: dup
       4: invokespecial #3                  // Method java/lang/Throwable."<init>":()V
       7: athrow
       8: astore_1
       9: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      12: ldc           #5                  // String Finally!
      14: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      17: aload_1
      18: athrow
    Exception table:
       from    to  target type
           0     9     8   any
}

Pas de "GOTO".

Pour comprendre pourquoi les optimisations ne peuvent pas être effectuées, il est utile de comprendre les mécanismes sous-jacents. L'exemple le plus succinct que j'ai pu trouver a été implémenté dans les macros C à l' adresse : http://www.di.unipi.it/~nids/docs/longjump_try_trow_catch.html

#include <stdio.h>
#include <setjmp.h>
#define TRY do{ jmp_buf ex_buf__; switch( setjmp(ex_buf__) ){ case 0: while(1){
#define CATCH(x) break; case x:
#define FINALLY break; } default:
#define ETRY } }while(0)
#define THROW(x) longjmp(ex_buf__, x)

Les compilateurs ont souvent du mal à déterminer si un saut peut être localisé vers X, Y et Z, donc ils sautent les optimisations dont ils ne peuvent garantir la sécurité, mais l'implémentation elle-même est plutôt légère.

Encore un microbenchmark ( source ).

J'ai créé un test dans lequel je mesure la version de code try-catch et no-try-catch en fonction d'un pourcentage d'exception. Un pourcentage de 10% signifie que 10% des cas de test avaient une division par zéro cas. Dans une situation, il est géré par un bloc try-catch, dans l'autre par un opérateur conditionnel. Voici mon tableau de résultats:

OS: Windows 8 6.2 x64
JVM: Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 23.25-b01

Pourcentage | Résultat (essayer / si, ns)   
    0% | 88/90   
    1% | 89/87    
    10% | 86/97    
    90% | 85/83   

Ce qui dit qu'il n'y a aucune différence significative entre ces cas.

J'ai trouvé la capture de NullPointException assez chère. Pour les opérations de 1,2 km, le temps était de 200 ms et 12 ms lorsque je l'ai géré de la même manière, if(object==null)ce qui était une bonne amélioration pour moi.