Die Schleife hat eine bessere Leistung? Warum?

String s = "";
for(i=0;i<....){
    s = some Assignment;
}

oder

for(i=0;i<..){
    String s = some Assignment;
}

Ich brauche nicht zu verwenden, " s " außerhalb der Schleife immer und immer wieder.
Die erste option ist vielleicht auch besser, da ein neues String ist nicht initialisiert jedes mal. Die zweite jedoch in den Bereich der Variablen begrenzt auf die Schleife selbst.

EDIT: In Reaktion auf Milhous Antwort. Es wäre sinnlos, weisen Sie die Zeichenfolge, um eine Konstante innerhalb einer Schleife wäre es nicht? Nein, hier 'einige Abtretung" bedeutet einen Wechsel Wert wurde aus der Liste Durchlaufen.

Auch, die Frage ist nicht, weil ich bin besorgt über memory-management. Möchte nur wissen, was besser ist.

  • Es ist nicht ungewöhnlich, um zu iterieren über eine collection von strings angegeben als Literale. Zum Beispiel werden die Spaltenüberschriften einer Tabelle kann hart codiert als String[]. Was ist wichtig, obwohl, ist, dass die gleiche Zuordnung geschieht in beiden Fällen, und so ist es nicht beeinflussen die Antwort.
  • Ein weiterer Kommentar: vergessen Sie nicht, dass wenn du nicht gehst, um den Wert zu ändern von s sollten Sie erklären es final. Viele Java-Programmierer vergessen, dass all zu oft.
InformationsquelleAutor |
  1. 108

    Begrenztem Umfang ist die Beste

    Verwenden Sie die zweite option:

    for ( ... ) {
  String s = ...;
}

    Umfang nicht auf die Leistung Auswirken

    Wenn Sie das disassemblieren von code ist der kompilierte von jedem (mit dem JDK ist javap tool), sieht man, dass die Schleife kompiliert, die genau die gleiche JVM-Instruktionen in beiden Fällen. Beachten Sie auch, dass Brian R. Bondy ' s "Option #3" ist identisch zu Option #1. Nichts extra Hinzugefügt wird oder vom stack entfernt, wenn über den engeren Rahmen und die gleichen Daten verwendet werden, auf dem stack in beiden Fällen.

    Vermeiden Vorzeitigen Initialisierung

    Der einzige Unterschied zwischen den beiden Fällen ist, dass im ersten Beispiel die variable s ist unnötig initialisiert. Dies ist ein weiteres Problem aus der Position der Variablen-Deklaration. Dies fügt zwei verschwendet Anweisungen (zum laden eine string-Konstante, und speichern Sie es in einen stack-frame, slot). Ein gutes tool für die statische Analyse wird Sie warnen, dass Sie nie Lesen den Wert, den Sie zuweisen s, und ein guter JIT-compiler wird wahrscheinlich umgehen, aber zur Laufzeit.

    Könnten Sie dieses Problem beheben, indem einfach eine leere Deklaration (d.h., String s;), aber dies wird als schlechte Praxis und hat einen weiteren Nebeneffekt, die unten besprochen.

    Oft einen falschen Wert wie null einer Variablen zugewiesen ist, einfach zu hush zu einem compiler-Fehler, dass eine variable gelesen wird, ohne dass Sie initialisiert wurde. Dieser Fehler kann als ein Hinweis, dass der Geltungsbereich von Variablen ist zu groß, und es wird erklärt, bevor es ist notwendig, um einen gültigen Wert. Leere Deklarationen zwingen Sie zu denken, jedes code-Pfad; ignorieren Sie nicht diese wertvolle Warnung durch die Zuordnung einen falschen Wert.

    Sparen Stack-Slots

    Wie erwähnt, während die JVM-Instruktionen sind die gleichen in beiden Fällen, es ist die subtile Seite-Effekt, der macht es am besten, an einem JVM-Ebene, verwenden die meisten beschränkten Umfang möglich. Sichtbar wird dies in der "local-variable-Tabelle" für die Methode. Überlegen Sie, was passiert, wenn Sie mehrere Schleifen, mit den Variablen, die in unnötig großer Umfang:

    void x(String[] strings, Integer[] integers) {
  String s;
  for (int i = 0; i < strings.length; ++i) {
    s = strings[0];
    ...
  }
  Integer n;
  for (int i = 0; i < integers.length; ++i) {
    n = integers[i];
    ...
  }
}

    Den Variablen s und n deklariert werden könnte, innerhalb Ihrer jeweiligen loops, aber da Sie nicht sind, verwendet der compiler zwei "slots" in den stack-frame. Wenn Sie waren innerhalb der Schleife deklariert, kann der compiler die Wiederverwendung der gleichen Steckplatz, so dass der stack-frame kleiner.

    , Was Wirklich Zählt

    Jedoch, die meisten dieser Probleme sind unwesentlich. Ein guter JIT-compiler werden sehen, es ist nicht möglich, Lesen Sie den ersten Wert, den Sie verschwenderisch zuweisen, und optimieren Sie die Zuweisung entfernt. Spart einen Steckplatz, die hier oder dort nicht gehen, um Pause machen oder Ihre Bewerbung.

    Die wichtige Sache ist, um Ihren code lesbar und leicht zu pflegen, und in dieser Hinsicht mit begrenztem Umfang ist deutlich besser. Die kleineren Geltungsbereich einer variable ist, desto leichter ist es zu verstehen, wie es verwendet wird, und welche Auswirkungen änderungen am code vorgenommen haben.

    • Ich bin noch nicht voll überzeugt, aber ich Sie gelöscht, meine Antwort, weil es falsch war, aber für die Referenz in dieser Frage. Hier ist, was ich hatte: {//entfernen Sie nicht die Klammern String s; for(i=0;i<....){ s = einige Zuweisung; } }
    • Ich würde abstimmen, bis dieser Kommentar zweimal, wenn ich könnte. Ich würde auch tag die Frage "früh-Optimierung".
    • Was für eine ausgezeichnete Antwort, ich würde auch Stimmen, es mehrere Male, wenn ich könnte.
    • Ich hatte nicht gespielt, mit javap vor, so ich habe in einer for-Schleife, wird das Datum und setzt die Zeichenfolge s in ein Datum.toString. Die Demontage habe ich, zeigten, dass der code anders ist. Sie können sehen, dass s wird jede Schleife in der inneren. Ist das etwas, dass der jit-compiler möglicherweise beheben?
    • T. - ich bin mir nicht sicher, ob ich verstehe, was Sie beschreiben. Wenn du meinst, dass der gleiche Wert zugewiesen wurde String bei jeder iteration der Schleife, und Sie Fragen sich, ob diese Berechnung können Sie "hochgezogen", ja, es ist möglich, aber es hängt von der JVM.
    • Meine Frage war über den "Anwendungsbereich nicht auf die Leistung auswirken" Abschnitt. Da ich neugierig war, sah ich auf dem javap Ausgabe einer Klasse die das Beispiel mit der variable definiert, die innerhalb und außerhalb der Schleife. Javap zeigt, dass der code anders ist, mit ein ldc und astore innerhalb der Schleife für den innen-initialisiert-version und dieser code ist außerhalb der Schleife für die ooutside initialisiert version. Ich versuche herauszufinden, wenn mir etwas fehlt, da Allgemeine Konsens scheint zu sein, der code sollte auch nicht anders sein. Ich überprüfte die Klassen von Eclipse und Netbeans.
    • Sprechen Sie über die erste, vergebliche Zuordnung von "" zu s im ersten Beispiel in der original-post? Der Wert, der nie Lesen, bevor Sie überschrieben wird bei der ersten iteration der Schleife? Das ist, was ich Rede in dem Abschnitt "Vermeiden Sie die Vorzeitige Initialisierung"; die ldc und astore Anweisungen verschwendet werden, weil dieser Wert kann nie gelesen werden, bevor die variable zugewiesen. Der code inside die Schleife ist die gleiche. Die Initialisierung (Belegung) der Variablen ist ein eigenes Thema aus dem Bereich der Variablen.

    InformationsquelleAutor erickson
  2. 22

    In Theorie, es ist eine Verschwendung von Ressourcen zu deklarieren die Zeichenfolge innerhalb der Schleife.
    In Praxis, aber die snippets, die Sie präsentiert wird kompilieren bis hin zu den gleichen code (Deklaration außerhalb der Schleife).

    So, wenn dein compiler hat jede Menge Optimierung, da gibt es keinen Unterschied.

    • Der Bezug ist nur innerhalb der stack-frame für diese Methode aufrufen, richtig?
    • Richtig!!!!
    • Ich glaube, Sie missverstanden, was 1800-INFORMATIONEN geschrieben. Die Unveränderlichkeit der Java-strings ist hier irrelevant: die "einige Zuweisung" erzeugt einen neuen String, der jedes mal, ob oder nicht String ist unveränderlich.
    • Was ist, wenn someAssignment ist nur einer hartcodierten Zeichenfolge?
    • Aktualisiert die Frage. Zuweisen einer hart codierten string wäre unlogisch.
    • Welche Theorie ist es, die Ihnen sagt, dass Deklaration eine variable Ressourcen verschwendet werden?
    • jrudolph: Erstellen eines neuen, leeren string erzeugt einen neuen garbage Collection-Objekt, wenn ich erinnere mich an meine Java-richtig.

    InformationsquelleAutor Esteban Araya
  3. 17

    Im Allgemeinen würde ich wählen Sie die zweite, weil der Umfang der " s " - Variablen ist beschränkt auf die Schleife. Vorteile:

    • Das ist besser für die Programmierer, da Sie nicht haben, um sorgen über 's" wird wieder irgendwo später in der Funktion
    • Das ist besser für den compiler, da der Gültigkeitsbereich der Variablen ist kleiner, und so kann es möglicherweise tun mehr Analyse und Optimierung
    • Das ist besser für die zukünftigen Leser, weil Sie nicht Fragen, warum die 's' - variable deklariert, die außerhalb der Schleife, wenn es nie verwendet, später
    InformationsquelleAutor Greg Hewgill
  4. 6

    Wenn Sie möchten, um die Geschwindigkeit for-Schleifen, ich bevorzuge die Deklaration einer variable max neben der Theke, so dass keine wiederholte Suchvorgänge für die condidtion sind erforderlich:

    statt

    for (int i = 0; i < array.length; i++) {
  Object next = array[i];
}

    Ich lieber

    for (int i = 0, max = array.lenth; i < max; i++) {
  Object next = array[i];
}

    Alle anderen Dinge, die Sie berücksichtigen sollten, ist bereits gesagt worden, also nur meine zwei Cent (siehe ericksons post)

    Greetz, GHad

    InformationsquelleAutor GHad
  5. 4

    Hinzufügen ein bisschen zu @Esteban Araya Antwort, Sie werden beide erfordern die Schaffung einer neuen Zeichenfolge jedes mal durch die Schleife (als Rückgabewert der some Assignment Ausdruck). Diese Zeichenfolgen werden müssen, die garbage Collection so oder so.

    • Ich dachte das gleiche.
    • Nicht unbedingt. Wir wissen nicht, was Sie zugewiesen wurden, um "s" in der Schleife. Vielleicht hat der eine string-Konstante zugewiesen wird, in der PermGen space und wird nie Müll gesammelt. Alles was wir wissen ist, dass was auch immer es ist, es ist die gleiche in beiden Fällen, also egal.
    • Ich bin damit einverstanden, dass könnte es sein eine string-Konstante, aber in diesem Fall erwarte ich, würde der compiler wahrscheinlich constant propagation zu bewegen, s aus dem Körper der Schleife. Ich war der Annahme, es war nicht eine Konstante, weil eine vernünftige Programmierer hätte das gleiche getan.
    • Ich wusste nicht, dass die gleiche string-Konstante, die in jeder iteration. Siehe mein Kommentar auf die OP.
    • Ja, in diesem Fall gäbe es keine optimsation
    InformationsquelleAutor 1800 INFORMATION
  6. 3

    Ich weiß, das ist eine alte Frage, aber ich dachte, ich fügen Sie ein wenig, dass leicht Verwandte.

    Habe ich bemerkt, während das surfen im Java-source-code, einige Methoden, wie String.contentEquals (ebenfalls unten) macht redundante lokale Variablen sind lediglich Kopien der Klassenvariablen. Ich glaube, dass ein Kommentar irgendwo, dass impliziert, dass der Zugriff auf lokale Variablen schneller ist als der Zugriff auf Klassenvariablen.

    In diesem Fall "v1" und "v2" sind scheinbar überflüssig und könnte abgeschafft werden, um den code vereinfachen, wurden aber Hinzugefügt, um die Leistung zu verbessern.

    public boolean contentEquals(StringBuffer sb) {
    synchronized(sb) {
        if (count != sb.length())
            return false;
        char v1[] = value;
        char v2[] = sb.getValue();
        int i = offset;
        int j = 0;
        int n = count;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
                return false;
        }
    }
    return true;
}
    • Das war wohl mehr nützlich auf alten VMs, als es jetzt ist. Ich habe eine harte Zeit zu glauben, dass einen Unterschied macht, auf HotSpot.
    InformationsquelleAutor
  7. 1

    Scheint es mir, dass wir mehr brauchen Spezifikation des Problems.

    Den 

    s = some Assignment;

    ist nicht angegeben, um welche Art von Zuordnung es ist. Wenn die Zuweisung 

    s = "" + i + "";

    dann ein neues stechen muss zugeordnet werden.

    aber wenn es 

    s = some Constant;

    s nur um den Konstanten-Speicher, und damit die erste version wäre mehr Speicher effizient.

    Scheint, ich etwas albern, sich sorgen über zu viel Optimierung einer for-Schleife für eine interpretierte lang IMHO.

    InformationsquelleAutor Milhous
  8. 1

    Wenn ich mit mehreren threads (50+) dann habe ich festgestellt, dass dies ein sehr effektiver Weg, der Umgang mit ghost-thread Probleme mit nicht in der Lage, zu schließen, einen Prozess richtig ....wenn ich falsch bin, bitte lassen Sie mich wissen, warum ich falsch Liege:

    Process one;
BufferedInputStream two;
try{
one = Runtime.getRuntime().exec(command);
two = new BufferedInputStream(one.getInputStream());
}
}catch(e){
e.printstacktrace
}
finally{
//null to ensure they are erased
one = null;
two = null;
//nudge the gc
System.gc();
}
    InformationsquelleAutor
Schreibe einen Kommentar