Ist es teuer, Try-Catch-Blöcke zu verwenden, auch wenn niemals eine Ausnahme ausgelöst wird?

Wir wissen, dass es teuer ist, Ausnahmen zu erwischen. Aber ist es auch teuer, einen Try-Catch-Block in Java zu verwenden, selbst wenn niemals eine Ausnahme ausgelöst wird?

Ich habe die Frage / Antwort zum Stapelüberlauf gefunden. Warum sind Versuchsblöcke teuer? , aber es ist für .NET .

tryhat fast keine Kosten. Anstatt die Arbeit zur Einrichtung des tryzur Laufzeit zu erledigen, sind die Metadaten des Codes zur Kompilierungszeit so strukturiert, dass beim Auslösen einer Ausnahme jetzt eine relativ teure Operation ausgeführt wird, bei der der Stapel hochgefahren wird und geprüft wird, ob tryBlöcke vorhanden sind, die dies abfangen würden Ausnahme. tryKann aus der Sicht eines Laien genauso gut frei sein. Es wird tatsächlich die Ausnahme ausgelöst, die Sie kostet - aber wenn Sie nicht Hunderte oder Tausende von Ausnahmen auslösen, werden Sie die Kosten immer noch nicht bemerken.

tryhat einige kleinere Kosten damit verbunden. Java kann einige Optimierungen für Code in einem tryBlock nicht vornehmen, die es sonst tun würde. Beispielsweise ordnet Java Anweisungen in einer Methode häufig neu an, damit sie schneller ausgeführt wird. Java muss jedoch auch sicherstellen, dass beim Auslösen einer Ausnahme die Ausführung der Methode so beobachtet wird, als würden ihre im Quellcode geschriebenen Anweisungen ausgeführt um bis zu einer Zeile.

Denn in einem tryBlock kann eine Ausnahme ausgelöst werden (in jeder Zeile des try-Blocks! Einige Ausnahmen werden asynchron ausgelöst, z. B. durch Aufrufen stopeines Threads (der veraltet ist), und sogar darüber hinaus kann OutOfMemoryError fast überall auftreten) kann abgefangen werden und Code wird anschließend auf dieselbe Weise weiter ausgeführt. Es ist schwieriger, über Optimierungen nachzudenken, die vorgenommen werden können, sodass die Wahrscheinlichkeit geringer ist, dass sie auftreten. (Jemand müsste den Compiler programmieren, um dies zu tun, die Richtigkeit zu begründen und zu garantieren usw. Es wäre ein großer Schmerz für etwas, das "außergewöhnlich" sein soll.) Aber auch in der Praxis werden Sie solche Dinge nicht bemerken.

Lassen Sie es uns messen, sollen wir?

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);
        }
    }
}

Auf meinem Computer wird Folgendes gedruckt:

try     0.598 ns
no try  0.601 ns

Zumindest in diesem trivialen Beispiel hatte die try-Anweisung keinen messbaren Einfluss auf die Leistung. Fühlen Sie sich frei, komplexere zu messen.

Im Allgemeinen empfehle ich, sich keine Gedanken über die Leistungskosten von Sprachkonstrukten zu machen, bis Sie Hinweise auf ein tatsächliches Leistungsproblem in Ihrem Code haben. Oder wie Donald Knuth es ausdrückte : "Vorzeitige Optimierung ist die Wurzel allen Übels".

tryIch catchkann einen Einfluss auf die Leistung haben. Dies liegt daran, dass JVM dadurch keine Optimierungen vornehmen kann. Joshua Bloch sagte in "Effective Java" Folgendes:

• Das Platzieren von Code in einem Try-Catch-Block verhindert bestimmte Optimierungen, die moderne JVM-Implementierungen andernfalls ausführen könnten.

Ja, wie die anderen gesagt haben, verhindert ein tryBlock einige Optimierungen in den ihn {}umgebenden Zeichen. Insbesondere muss der Optimierer davon ausgehen, dass an jedem Punkt innerhalb des Blocks eine Ausnahme auftreten kann, sodass nicht garantiert werden kann, dass Anweisungen ausgeführt werden.

Beispielsweise:

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

Ohne das könnte tryder Wert, dem die Zuweisung berechnet wurde, xals "allgemeiner Unterausdruck" gespeichert und zur Zuweisung wiederverwendet werden y. Aufgrund der tryTatsache, dass es keine Garantie dafür gibt, dass der erste Ausdruck jemals ausgewertet wurde, muss der Ausdruck neu berechnet werden. Dies ist normalerweise keine große Sache im "geradlinigen" Code, kann aber in einer Schleife von Bedeutung sein.

Es ist jedoch zu beachten, dass dies NUR für JITCed-Code gilt. javac führt nur eine geringfügige Optimierung durch, und der Bytecode-Interpreter hat keine Kosten für das Betreten / Verlassen eines tryBlocks. (Es werden keine Bytecodes generiert, um die Blockgrenzen zu markieren.)

Und für Bests:

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

Ausgabe:

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

Javap-Ausgabe:

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
}

Kein "GOTO".

Um zu verstehen, warum die Optimierungen nicht durchgeführt werden können, ist es hilfreich, die zugrunde liegenden Mechanismen zu verstehen. Das prägnanteste Beispiel, das ich finden konnte, wurde in C-Makros unter folgender Adresse implementiert: 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)

Compiler haben häufig Schwierigkeiten zu bestimmen, ob ein Sprung auf X, Y und Z lokalisiert werden kann, sodass sie Optimierungen überspringen, die sie nicht als sicher garantieren können, aber die Implementierung selbst ist eher leicht.

Noch ein Mikrobenchmark ( Quelle ).

Ich habe einen Test erstellt, in dem ich die Codeversion try-catch und no-try-catch anhand eines Ausnahmeprozentsatzes messe. 10% Prozent bedeutet, dass 10% der Testfälle durch Null geteilt wurden. In einer Situation wird es von einem Try-Catch-Block behandelt, in der anderen von einem bedingten Operator. Hier ist meine Ergebnistabelle:

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

Prozentsatz | Ergebnis (try / if, ns)   
    0% | 88/90   
    1% | 89/87    
    10% | 86/97    
    90% | 85/83   

Was besagt, dass es keinen signifikanten Unterschied zwischen diesen Fällen gibt.

Ich fand es ziemlich teuer, NullPointException zu fangen. Für 1,2-km-Operationen betrug die Zeit 200 ms und 12 ms, als ich sie auf die gleiche Weise handhabte, if(object==null)was für mich eine ziemlich gute Verbesserung war.