Apakah mahal untuk menggunakan blok uji coba bahkan jika pengecualian tidak pernah dilempar?

Kita tahu mahal untuk menangkap pengecualian. Tapi, apakah terlalu mahal untuk menggunakan blok try-catch di Jawa bahkan jika pengecualian tidak pernah dilontarkan?

Saya menemukan pertanyaan / jawaban Stack Overflow. Mengapa coba blok mahal? , tetapi untuk .NET .

tryhampir tidak ada biaya sama sekali. Alih-alih melakukan pekerjaan menyiapkan trysaat runtime, metadata kode ini disusun pada waktu kompilasi sehingga ketika pengecualian dilemparkan, sekarang melakukan operasi yang relatif mahal berjalan menumpuk dan melihat apakah ada tryblok yang akan menangkap ini pengecualian. Dari sudut pandang orang awam, trymungkin juga gratis. Ini sebenarnya membuang pengecualian yang dikenakan biaya - tetapi kecuali Anda melempar ratusan atau ribuan pengecualian, Anda tetap tidak akan menyadari biayanya.

trymemiliki beberapa biaya kecil yang terkait dengannya. Java tidak dapat melakukan beberapa optimasi pada kode di tryblok yang seharusnya dilakukan. Sebagai contoh, Java akan sering mengatur ulang instruksi dalam suatu metode untuk membuatnya berjalan lebih cepat - tetapi Java juga perlu menjamin bahwa jika pengecualian dilemparkan, eksekusi metode diamati seolah-olah pernyataannya, sebagaimana ditulis dalam kode sumber, dieksekusi untuk beberapa baris.

Karena dalam tryblok pengecualian dapat dilempar (pada baris apa pun di blok coba! Beberapa pengecualian dilemparkan secara tidak serempak, seperti dengan memanggil stopThread (yang sudah usang), dan bahkan selain itu OutOfMemoryError dapat terjadi hampir di mana saja) dan belum dapat ditangkap dan kode terus dieksekusi setelah itu dalam metode yang sama, lebih sulit untuk alasan tentang optimasi yang dapat dilakukan, sehingga mereka cenderung terjadi. (Seseorang harus memprogram kompiler untuk melakukannya, alasan dan menjamin kebenaran, dll. Ini akan sangat menyusahkan untuk sesuatu yang berarti 'luar biasa') Tapi sekali lagi, dalam praktiknya Anda tidak akan melihat hal-hal seperti ini.

Mari kita ukur, ya?

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

Di komputer saya, ini mencetak sesuatu seperti:

try     0.598 ns
no try  0.601 ns

Setidaknya dalam contoh sepele ini, pernyataan coba tidak memiliki dampak yang terukur pada kinerja. Jangan ragu untuk mengukur yang lebih kompleks.

Secara umum, saya sarankan untuk tidak khawatir tentang biaya kinerja konstruksi bahasa sampai Anda memiliki bukti masalah kinerja aktual dalam kode Anda. Atau seperti Donald Knuth menempatkan itu: "optimasi prematur adalah akar dari segala kejahatan".

trySaya catchmungkin memiliki dampak pada kinerja. Ini karena mencegah JVM dari melakukan beberapa optimasi. Joshua Bloch, dalam "Java Efektif," mengatakan yang berikut:

• Menempatkan kode di dalam blok uji coba menghambat optimasi tertentu yang mungkin dilakukan oleh implementasi JVM modern.

Yap, seperti yang dikatakan orang lain, satu tryblok menghambat beberapa optimisasi di seluruh {}karakter yang mengelilinginya. Secara khusus, pengoptimal harus mengasumsikan bahwa pengecualian dapat terjadi pada titik mana pun dalam blok, sehingga tidak ada jaminan bahwa pernyataan dieksekusi.

Sebagai contoh:

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

Tanpa itu try, nilai yang dihitung untuk xditugaskan dapat disimpan sebagai "subekspresi umum" dan digunakan kembali untuk ditugaskan y. Tetapi karena trytidak ada jaminan bahwa ekspresi pertama pernah dievaluasi, maka ekspresi tersebut harus dihitung ulang. Ini biasanya bukan masalah besar dalam kode "garis lurus", tetapi bisa signifikan dalam satu lingkaran.

Namun perlu dicatat bahwa ini HANYA berlaku untuk kode JITCed. javac hanya melakukan sejumlah optimasi piddling, dan tidak ada biaya untuk penerjemah bytecode untuk memasuki / meninggalkan tryblok. (Tidak ada bytecode yang dihasilkan untuk menandai batas blok.)

Dan untuk bestsss:

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

Keluaran:

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

output 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
}

Tidak ada "GOTO".

Untuk memahami mengapa optimasi tidak dapat dilakukan, penting untuk memahami mekanisme yang mendasarinya. Contoh paling ringkas yang dapat saya temukan diimplementasikan dalam makro C di: 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 sering mengalami kesulitan menentukan apakah lompatan dapat dilokalisasi ke X, Y dan Z sehingga mereka melewati optimisasi yang tidak dapat mereka yakini aman, tetapi implementasinya sendiri agak ringan.

Namun microbenchmark ( sumber ) lain.

Saya membuat tes di mana saya mengukur versi kode coba-tangkap dan tidak-coba-tangkap berdasarkan persentase pengecualian. Persentase 10% berarti bahwa 10% dari kasus uji dibagi dengan nol kasus. Dalam satu situasi itu ditangani oleh blok try-catch, yang lain oleh operator bersyarat. Ini tabel hasil saya:

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

Persentase | Hasil (coba / jika, ns)   
    0% | 88/90   
    1% | 89/87    
    10% | 86/97    
    90% | 85/83   

Yang mengatakan bahwa tidak ada perbedaan yang signifikan antara semua kasus ini.

Saya menemukan penangkapan NullPointException cukup mahal. Untuk operasi 1.2k waktu adalah 200ms dan 12ms ketika saya mengatasinya dengan cara yang sama dengan if(object==null)yang merupakan peningkatan yang cukup bagi saya.