Apakah lebih baik menggunakan kembali StringBuilder dalam satu lingkaran?

Saya memiliki pertanyaan terkait kinerja tentang penggunaan StringBuilder. Dalam loop yang sangat panjang saya memanipulasi StringBuilderdan meneruskannya ke metode lain seperti ini:

for (loop condition) {
    StringBuilder sb = new StringBuilder();
    sb.append("some string");
    . . .
    sb.append(anotherString);
    . . .
    passToMethod(sb.toString());
}

Apakah instantiating StringBuilderpada setiap siklus loop adalah solusi yang baik? Dan apakah memanggil delete lebih baik, seperti berikut ini?

StringBuilder sb = new StringBuilder();
for (loop condition) {
    sb.delete(0, sb.length);
    sb.append("some string");
    . . .
    sb.append(anotherString);
    . . .
    passToMethod(sb.toString());
}

Yang kedua sekitar 25% lebih cepat dalam tolok ukur mini saya.

public class ScratchPad {

    static String a;

    public static void main( String[] args ) throws Exception {
        long time = System.currentTimeMillis();
        for( int i = 0; i < 10000000; i++ ) {
            StringBuilder sb = new StringBuilder();
            sb.append( "someString" );
            sb.append( "someString2"+i );
            sb.append( "someStrin4g"+i );
            sb.append( "someStr5ing"+i );
            sb.append( "someSt7ring"+i );
            a = sb.toString();
        }
        System.out.println( System.currentTimeMillis()-time );
        time = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for( int i = 0; i < 10000000; i++ ) {
            sb.delete( 0, sb.length() );
            sb.append( "someString" );
            sb.append( "someString2"+i );
            sb.append( "someStrin4g"+i );
            sb.append( "someStr5ing"+i );
            sb.append( "someSt7ring"+i );
            a = sb.toString();
        }
        System.out.println( System.currentTimeMillis()-time );
    }
}

Hasil:

25265
17969

Perhatikan bahwa ini dengan JRE 1.6.0_07.

Berdasarkan ide Jon Skeet yang di edit, inilah versi 2. Hasil yang sama.

public class ScratchPad {

    static String a;

    public static void main( String[] args ) throws Exception {
        long time = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for( int i = 0; i < 10000000; i++ ) {
            sb.delete( 0, sb.length() );
            sb.append( "someString" );
            sb.append( "someString2" );
            sb.append( "someStrin4g" );
            sb.append( "someStr5ing" );
            sb.append( "someSt7ring" );
            a = sb.toString();
        }
        System.out.println( System.currentTimeMillis()-time );
        time = System.currentTimeMillis();
        for( int i = 0; i < 10000000; i++ ) {
            StringBuilder sb2 = new StringBuilder();
            sb2.append( "someString" );
            sb2.append( "someString2" );
            sb2.append( "someStrin4g" );
            sb2.append( "someStr5ing" );
            sb2.append( "someSt7ring" );
            a = sb2.toString();
        }
        System.out.println( System.currentTimeMillis()-time );
    }
}

Hasil:

5016
7516

Dalam filosofi penulisan kode yang solid, selalu lebih baik untuk meletakkan StringBuilder Anda di dalam loop Anda. Dengan cara ini ia tidak keluar dari kode yang dimaksudkan.

Kedua, peningkatan terbesar di StringBuilder berasal dari memberikan ukuran awal untuk menghindarinya tumbuh lebih besar saat loop berjalan

for (loop condition) {
  StringBuilder sb = new StringBuilder(4096);
}

Lebih cepat lagi:

public class ScratchPad {

    private static String a;

    public static void main( String[] args ) throws Exception {
        long time = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder( 128 );

        for( int i = 0; i < 10000000; i++ ) {
            // Resetting the string is faster than creating a new object.
            // Since this is a critical loop, every instruction counts.
            //
            sb.setLength( 0 );
            sb.append( "someString" );
            sb.append( "someString2" );
            sb.append( "someStrin4g" );
            sb.append( "someStr5ing" );
            sb.append( "someSt7ring" );
            setA( sb.toString() );
        }

        System.out.println( System.currentTimeMillis()-time );
    }

    private static void setA( String aString ) {
        a = aString;
    }
}

Dalam filosofi penulisan kode yang solid, cara kerja bagian dalam metode harus disembunyikan dari objek yang menggunakan metode tersebut. Jadi tidak ada bedanya dari perspektif sistem apakah Anda mendeklarasikan ulang StringBuilder di dalam atau di luar loop. Karena mendeklarasikannya di luar loop lebih cepat, dan tidak membuat kode lebih rumit untuk dibaca, maka gunakan kembali objek daripada memulihkannya.

Meskipun kodenya lebih rumit, dan Anda tahu pasti bahwa pembuatan instance objek adalah penghambat, beri komentar.

Tiga proses dengan jawaban ini:

$ java ScratchPad
1567
$ java ScratchPad
1569
$ java ScratchPad
1570

Tiga proses dengan jawaban lain:

$ java ScratchPad2
1663
2231
$ java ScratchPad2
1656
2233
$ java ScratchPad2
1658
2242

Meskipun tidak signifikan, pengaturan StringBuilderukuran buffer awal akan memberikan keuntungan yang kecil.

Oke, sekarang saya mengerti apa yang sedang terjadi, dan itu masuk akal.

Saya mendapat kesan bahwa toStringbaru saja melewati yang mendasari char[]ke dalam konstruktor String yang tidak mengambil salinan. Salinan kemudian akan dibuat pada operasi "tulis" berikutnya (misalnya delete). Saya yakin ini adalah kasus StringBufferdi beberapa versi sebelumnya. (Ini bukan sekarang.) Tapi tidak - toStringhanya meneruskan array (dan indeks dan panjang) ke Stringkonstruktor publik yang mengambil salinan.

Jadi dalam kasus "reuse the StringBuilder" kita benar-benar membuat satu salinan data per string, menggunakan array karakter yang sama di buffer sepanjang waktu. Jelas membuat baru StringBuildersetiap kali membuat buffer yang mendasari baru - dan kemudian buffer itu disalin (agak sia-sia, dalam kasus khusus kami, tetapi dilakukan untuk alasan keamanan) saat membuat string baru.

Semua ini mengarah pada versi kedua yang pasti lebih efisien - tetapi pada saat yang sama saya masih mengatakan itu kode yang lebih jelek.

Karena saya rasa itu belum ditunjukkan, karena pengoptimalan yang dibangun ke dalam kompiler Java Sun, yang secara otomatis membuat StringBuilders (StringBuffers pra-J2SE 5.0) ketika melihat rangkaian String, contoh pertama dalam pertanyaan tersebut setara dengan:

for (loop condition) {
  String s = "some string";
  . . .
  s += anotherString;
  . . .
  passToMethod(s);
}

Mana yang lebih mudah dibaca, IMO, pendekatan yang lebih baik. Upaya Anda untuk mengoptimalkan dapat menghasilkan keuntungan di beberapa platform, tetapi berpotensi kehilangan yang lain.

Tetapi jika Anda benar-benar mengalami masalah dengan kinerja, maka pastikan, optimalkan. Saya akan mulai dengan secara eksplisit menentukan ukuran buffer dari StringBuilder, menurut Jon Skeet.

JVM modern benar-benar pintar tentang hal-hal seperti ini. Saya tidak akan menebak-nebak dan melakukan sesuatu yang hacky yang kurang dapat dipelihara / dibaca ... kecuali Anda melakukan benchmark yang tepat dengan data produksi yang memvalidasi peningkatan kinerja yang tidak sepele (dan mendokumentasikannya;)

Berdasarkan pengalaman saya dengan mengembangkan perangkat lunak pada Windows, saya akan mengatakan membersihkan StringBuilder selama loop Anda memiliki kinerja yang lebih baik daripada membuat Instansiasi StringBuilder dengan setiap iterasi. Menghapusnya membebaskan memori itu untuk segera ditimpa tanpa alokasi tambahan yang diperlukan. Saya tidak cukup paham dengan pengumpul sampah Java, tapi menurut saya membebaskan dan tidak ada realokasi (kecuali string Anda berikutnya menumbuhkan StringBuilder) lebih bermanfaat daripada instantiasi.

(Pendapat saya bertentangan dengan apa yang disarankan orang lain. Hmm. Saatnya untuk mengukurnya.)

Alasan mengapa melakukan 'setLength' atau 'delete' meningkatkan kinerja sebagian besar adalah kode 'mempelajari' ukuran buffer yang tepat, dan lebih sedikit untuk melakukan alokasi memori. Secara umum, saya menyarankan agar kompilator melakukan optimasi string . Namun, jika kinerjanya kritis, saya akan sering menghitung sebelumnya ukuran buffer yang diharapkan. Ukuran StringBuilder default adalah 16 karakter. Jika Anda tumbuh lebih dari itu, maka ukurannya harus diubah. Mengubah ukuran adalah saat performa hilang. Berikut patokan mini lain yang menggambarkan hal ini:

private void clear() throws Exception {
    long time = System.currentTimeMillis();
    int maxLength = 0;
    StringBuilder sb = new StringBuilder();

    for( int i = 0; i < 10000000; i++ ) {
        // Resetting the string is faster than creating a new object.
        // Since this is a critical loop, every instruction counts.
        //
        sb.setLength( 0 );
        sb.append( "someString" );
        sb.append( "someString2" ).append( i );
        sb.append( "someStrin4g" ).append( i );
        sb.append( "someStr5ing" ).append( i );
        sb.append( "someSt7ring" ).append( i );
        maxLength = Math.max(maxLength, sb.toString().length());
    }

    System.out.println(maxLength);
    System.out.println("Clear buffer: " + (System.currentTimeMillis()-time) );
}

private void preAllocate() throws Exception {
    long time = System.currentTimeMillis();
    int maxLength = 0;

    for( int i = 0; i < 10000000; i++ ) {
        StringBuilder sb = new StringBuilder(82);
        sb.append( "someString" );
        sb.append( "someString2" ).append( i );
        sb.append( "someStrin4g" ).append( i );
        sb.append( "someStr5ing" ).append( i );
        sb.append( "someSt7ring" ).append( i );
        maxLength = Math.max(maxLength, sb.toString().length());
    }

    System.out.println(maxLength);
    System.out.println("Pre allocate: " + (System.currentTimeMillis()-time) );
}

public void testBoth() throws Exception {
    for(int i = 0; i < 5; i++) {
        clear();
        preAllocate();
    }
}

Hasilnya menunjukkan penggunaan ulang objek sekitar 10% lebih cepat daripada membuat buffer dengan ukuran yang diharapkan.

LOL, pertama kali saya melihat orang membandingkan kinerja dengan menggabungkan string di StringBuilder. Untuk tujuan itu, jika Anda menggunakan "+", itu bisa lebih cepat; D. Tujuan menggunakan StringBuilder untuk mempercepat pengambilan seluruh string sebagai konsep "lokalitas".

Dalam skenario di mana Anda sering mengambil nilai String yang tidak perlu sering diubah, Stringbuilder memungkinkan kinerja pengambilan string yang lebih tinggi. Dan itulah tujuan menggunakan Stringbuilder .. tolong jangan MIS-Test tujuan intinya ..

Beberapa orang berkata, Pesawat terbang lebih cepat. Oleh karena itu, saya mengujinya dengan sepeda saya, dan ternyata pesawat bergerak lebih lambat. Tahukah Anda bagaimana saya mengatur pengaturan percobaan; D

Tidak secara signifikan lebih cepat, tetapi dari pengujian saya itu menunjukkan rata-rata menjadi beberapa mil lebih cepat menggunakan 1.6.0_45 64 bit: gunakan StringBuilder.setLength (0) daripada StringBuilder.delete ():

time = System.currentTimeMillis();
StringBuilder sb2 = new StringBuilder();
for (int i = 0; i < 10000000; i++) {
    sb2.append( "someString" );
    sb2.append( "someString2"+i );
    sb2.append( "someStrin4g"+i );
    sb2.append( "someStr5ing"+i );
    sb2.append( "someSt7ring"+i );
    a = sb2.toString();
    sb2.setLength(0);
}
System.out.println( System.currentTimeMillis()-time );

Cara tercepat adalah dengan menggunakan "setLength". Ini tidak akan melibatkan operasi penyalinan. Cara membuat StringBuilder baru harus benar-benar keluar . Lambatnya StringBuilder.delete (int start, int end) adalah karena ia akan menyalin array lagi untuk bagian yang mengubah ukuran.

 System.arraycopy(value, start+len, value, start, count-end);

Setelah itu, StringBuilder.delete () akan memperbarui StringBuilder.count ke ukuran baru. Sedangkan StringBuilder.setLength () hanya menyederhanakan update StringBuilder.count ke ukuran yang baru.

Yang pertama lebih baik untuk manusia. Jika yang kedua sedikit lebih cepat pada beberapa versi dari beberapa JVM, lalu apa?

Jika kinerja sangat penting, lewati StringBuilder dan tulis milik Anda sendiri. Jika Anda seorang programmer yang baik, dan mempertimbangkan bagaimana aplikasi Anda menggunakan fungsi ini, Anda seharusnya dapat membuatnya lebih cepat. Bermanfaat? Mungkin tidak.

Mengapa pertanyaan ini dipandang sebagai "pertanyaan favorit"? Karena pengoptimalan kinerja sangat menyenangkan, tidak peduli apakah itu praktis atau tidak.

Saya rasa tidak masuk akal untuk mencoba mengoptimalkan kinerja seperti itu. Hari ini (2019) kedua statment berjalan sekitar 11 detik untuk 100.000.000 loop di Laptop I5 saya:

    String a;
    StringBuilder sb = new StringBuilder();
    long time = 0;

    System.gc();
    time = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        StringBuilder sb3 = new StringBuilder();
        sb3.append("someString");
        sb3.append("someString2");
        sb3.append("someStrin4g");
        sb3.append("someStr5ing");
        sb3.append("someSt7ring");
        a = sb3.toString();
    }
    System.out.println(System.currentTimeMillis() - time);

    System.gc();
    time = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        sb.setLength(0);
        sb.delete(0, sb.length());
        sb.append("someString");
        sb.append("someString2");
        sb.append("someStrin4g");
        sb.append("someStr5ing");
        sb.append("someSt7ring");
        a = sb.toString();
    }
    System.out.println(System.currentTimeMillis() - time);

==> 11000 msec (deklarasi di dalam loop) dan 8236 msec (deklarasi loop luar)

Bahkan jika saya menjalankan program untuk pengurangan alamat dengan beberapa miliar pengulangan dengan selisih 2 detik. untuk 100 juta loop tidak ada bedanya karena program tersebut berjalan berjam-jam. Ketahuilah juga bahwa semuanya berbeda jika Anda hanya memiliki satu pernyataan tambahan:

    System.gc();
    time = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        StringBuilder sb3 = new StringBuilder();
        sb3.append("someString");
            a = sb3.toString();
    }
    System.out.println(System.currentTimeMillis() - time);

    System.gc();
    time = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        sb.setLength(0);
        sb.delete(0, sb.length());
        sb.append("someString");
        a = sb.toString();
    }
    System.out.println(System.currentTimeMillis() - time);

==> 3416 msec (loop dalam), 3555 msec (loop luar) Pernyataan pertama yang membuat StringBuilder dalam loop lebih cepat dalam kasus itu. Dan, jika Anda mengubah urutan eksekusi, ini jauh lebih cepat:

    System.gc();
    time = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        sb.setLength(0);
        sb.delete(0, sb.length());
        sb.append("someString");
        a = sb.toString();
    }
    System.out.println(System.currentTimeMillis() - time);

    System.gc();
    time = System.currentTimeMillis();
    for (int i = 0; i < 100000000; i++) {
        StringBuilder sb3 = new StringBuilder();
        sb3.append("someString");
            a = sb3.toString();
    }
    System.out.println(System.currentTimeMillis() - time);

==> 3638 msec (loop luar), 2908 msec (loop dalam)

Salam, Ulrich

Nyatakan sekali, dan tetapkan setiap kali. Ini adalah konsep yang lebih pragmatis dan dapat digunakan kembali daripada pengoptimalan.