String-Konkatenierungen

[robot]

Hallo, wann ist es eigentlich notwendig String-Konkatenierungen "manuell" mit StringBuilder/StringBuffer zu optimieren, wenn man mit einem Java 6 Compiler arbeitet?

Folgender Code wird scheinbar von javac automatisch zu einer Konkatenierung mittels StringBuilder optimiert, wie man z.B. im generierten Byte-Code sehen kann:

class Test {
public static void main(String[] args) {
  String s = "abc";
  // ...
  s += "def";
}
}

Wann genau kann ich mich auf diese automatische Optimierung verlassen und wann sollte ich sie (an performace-kritischen Stellen) selber ausprogrammieren?

 

[MQue]

StringBuffer immer dann verwenden, wenn oft concateniert wird, z.B.: in einer Schleife usw.
Wenn ein String einmal initialisiert wird und sich dann nicht mehr ändert, dann kannst du problemlos "String" verwenden.

 

[tfa]

Folgender Code wird scheinbar von javac automatisch zu einer Konkatenierung mittels StringBuilder optimiert, wie man z.B. im generierten Byte-Code sehen kann

Die Stringkonkatenierung mit + wird immer (wenn nötig) vom Compiler zu einer Konkatenierung mit StringBuilder umgesetzt. Fügt man so Compile-Time-Konstanten zusammen, ist ein Strringbuilder überflüssig und es wird gleich ein fertiger String im Bytecode erzeugt.

Wann genau kann ich mich auf diese automatische Optimierung verlassen und wann sollte ich sie (an performace-kritischen Stellen) selber ausprogrammieren?

Wenn du innerhalb einer Schleife einen String konkatenierst und den StringBuilder außerhalb definieren kannst.

 

[SlaterB]

optimiert werden kann meiner Ansicht nach eine einzelne Zeile
st += a + b+ c+ d+ e+ f;

bestenfalls mehrere String-Zeilen direkt hintereinander
st += a + b;
st += c+ d;
(auch schon fraglich was bei Exceptions usw. passiert)

unmöglich kann ich mir das für den Paradefall einer Schleife vorstellen:

for (int i=0; i<10; i++) {
  st += ", "+i;
}

hier vor der Schleife einen Builder einzufügen, nach der Schleife den String zu erstellen, das wäre schon sehr aufwendig,
besonders wenn noch anderer Code in der Schleife steht

 

[Final_Striker]

for (int i=0; i<10; i++) {
  st += ", "+i;
}

nach dem Decompilieren steht da sowas:

string st = "";
for(int i = 0; i < 10; i++)
   st = (new StringBuilder(string.valueOf(st))).append(", ").append(i).toString();

 

[SlaterB]

dass die Zeile für sich optimiert wird ist klar aber eben nicht das entscheidene,
sondern dass 10x ein StringBuilder und jeweils ein String erzeugt wird, in jedem Schleifendurchlauf

richtig optiomal braucht man nur EINEN StringBuilder

 

[Final_Striker]

Ja klar, ist ja immerhin besser als das Original. Optimal ist das aber natürlich nicht.

 

[tfa]

Ja klar, ist ja immerhin besser als das Original.

Was ist denn das Original?

 

[fastjack]

Spaßeshalber habe ich mal meinen QuickBench darauf losgelassen:

public class StringBenches {

    public static void main(String[] args) {
        QuickBench.benchNxM(10, 50000, new long[] { 1000 },
                new long[] { 1000}, new Bench[] {new StringConcatenation_Plus(),
                new StringConcatenation_Concat(), new StringConcatenation_StringBuffer(),
                new StringConcatenation_InnerStringBuffer(),
                new StringConcatenation_StringBuilder(),
                new StringConcatenation_InnerStringBuilder()});
    }

    /* einfaches s += ... */
    static class StringConcatenation_Plus implements Bench {
        public StringConcatenation_Plus() {
            super();
        }

        @Override
        public String getName() {
            return "String: Plus";
        }

        @Override
        public void reset() {
        }

        @Override
        public void prepare(long lm) {
        }

        @Override
        public void execute(long lm) {
            String s = "";
            for (int i = 0; i < lm; i++) {
                s += i;
            }
        }
    };

    /* s = s.concat(...) */
    static class StringConcatenation_Concat implements Bench {
        public StringConcatenation_Concat() {
            super();
        }

        @Override
        public String getName() {
            return "String: Concat";
        }

        @Override
        public void reset() {
        }

        @Override
        public void prepare(long lm) {
        }

        @Override
        public void execute(long lm) {
            String s = "";
            for (int i = 0; i < lm; i++) {
                s = s.concat(String.valueOf(i));
            }
        }
    };

    /* StringBuffer ausserhalb der Schleife */
    static class StringConcatenation_StringBuffer implements Bench {
        public StringConcatenation_StringBuffer() {
            super();
        }

        @Override
        public String getName() {
            return "String: StringBuffer";
        }

        @Override
        public void reset() {
        }

        @Override
        public void prepare(long lm) {
        }

        @Override
        public void execute(long lm) {
            StringBuffer s = new StringBuffer();
            for (int i = 0; i < lm; i++) {
                s.append(String.valueOf(i));
            }
        }
    };

    /* "optimiertes" Beispiel aus dem Thread */
    static class StringConcatenation_InnerStringBuffer implements Bench {
        public StringConcatenation_InnerStringBuffer() {
            super();
        }

        @Override
        public String getName() {
            return "String: In-StringBuffer";
        }

        @Override
        public void reset() {
        }

        @Override
        public void prepare(long lm) {
        }

        @Override
        public void execute(long lm) {
            String s = "";
            for (int i = 0; i < lm; i++) {
                s = new StringBuffer(String.valueOf(s)).append(String.valueOf(i)).toString();
            }
        }
    };

    /* StringBuilder ausserhalb der Schleife */
    static class StringConcatenation_StringBuilder implements Bench {
        public StringConcatenation_StringBuilder() {
            super();
        }

        @Override
        public String getName() {
            return "String: StringBuilder";
        }

        @Override
        public void reset() {
        }

        @Override
        public void prepare(long lm) {
        }

        @Override
        public void execute(long lm) {
            StringBuilder s = new StringBuilder();
            for (int i = 0; i < lm; i++) {
                s.append(String.valueOf(i));
            }
        }
    };

    /* "optimiertes" Beispiel aus dem Thread */
    static class StringConcatenation_InnerStringBuilder implements Bench {
        public StringConcatenation_InnerStringBuilder() {
            super();
        }

        @Override
        public String getName() {
            return "String: In-StringBuilder";
        }

        @Override
        public void reset() {
        }

        @Override
        public void prepare(long lm) {
        }

        @Override
        public void execute(long lm) {
            String s = "";
            for (int i = 0; i < lm; i++) {
                s = new StringBuilder(String.valueOf(s)).append(String.valueOf(i)).toString();
            }
        }
    };

}

+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| Bench                     |   Rounds |    Objects |       ms | ms (avg) |              nt |        nt (avg) |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
| String: Plus              |    1.000 |      1.000 |    2.872 |        2 |             ... |             ... |
| String: Concat            |    1.000 |      1.000 |    1.353 |        1 |             ... |             ... |
| String: StringBuffer      |    1.000 |      1.000 |       56 |        0 |             ... |             ... |
| String: In-StringBuffer   |    1.000 |      1.000 |    2.804 |        2 |             ... |             ... |
| String: StringBuilder     |    1.000 |      1.000 |       58 |        0 |             ... |             ... |
| String: In-StringBuilder  |    1.000 |      1.000 |    2.827 |        2 |             ... |             ... |
+---------------------------+----------+------------+----------+----------+-----------------+-----------------+
java version 1.6.0_20
OpenJDK Runtime Environment(build 1.6.0_20-b20)
OpenJDK Server VM(build 19.0-b09, mixed mode)
Linux(2.6.35-24-generic-pae) i386
Max memory: 858MB
Core 2 Duo, 2*2Ghz, 4MB RAM

Es werden jeweils 1000 mal die Zahlen von 0 bis 999 angehängt.

String: Plus *** ein einfaches konkatenieren durch +=
String: Concat *** ein konkatenieren durch die concat()-Methode
String: StringBuffer *** ein konkatenieren mittels EINEM StringBuffer und der append()-Methode
String: In-StringBuffer *** ein konkatenieren mittels mehreren StringBuffer und der append()-Methode (wie aus dem Beispiel)
String: StringBuilder *** ein konkatenieren mittels EINEM StringBuilder und der append()-Methode
String: In-StringBuilder *** ein konkatenieren mittels mehreren StringBuildern und der append()-Methode (wie aus dem Beispiel)

Summa summarum, wer hätte sich das denken können? Die Fassungen mit einem StringBuffer und einem StringBuilder sind natürlich die "schnellsten". Die Zahlen sind aber allerdings mit Vorsicht zu genießen,wegen Micro-Benchmarking und so weiter... Ich würde jetzt auch nicht raten, wenige Strings, wie in dem Beispiel zum Anfang, jetzt immer mit einem StringBuilder zu verbinden, es kommt halt auf den Fall an.
Nur zeigt das Dekompilat halt aber auch, das die automatischen Optimierungen des Kompilers nicht immer der bessere Weg sein müssen.

 

[Marco13]

OT:

Core 2 Duo, 2*2Ghz, 4MB RAM

G, vermutlich

 

[SlaterB]

Tipp zum Code:
selbst wenn Bench ein nötiges Interface ist, kann man immer noch eine Adapter-Klasse mit leeren Methoden erstellen
damit dann die eigentlichen Tests nicht diese ständig unnötig wiederholen müssen

ein Konstruktor, der nur super() aufruft, ist auch fraglich,

und wo ich grad dabei bei:
getName() könnte im Adapter einfach den Klassenname zurückgeben bisschen lang allerdings

 

[fastjack]

@SlaterB danke für die Tipps.

früher hatte ich auch mit dem Klassennamen experimentiert, war aber in der Zusammenfassung nicht sehr schön zu lesen.

@Marco13 ja, GB :lol:

 

[robot]

Vielen Dank für die schnelle Hilfe