Wie Java schreiben für Schleifen wiederholt zu vermeiden, dass die obere Berechnung gebundenen

Question

ich in der Regel

for (int i = 0, n = someMethod(); i < n; i++) 

in Vorzug

for (int i = 0; i < someMethod(); i++) 

schreiben zu vermeiden someMethod() wiederholt berechnet wird. Aber ich bin mir nie wirklich sicher, wann ich das tun muss. Wie schlau ist es, dass Java Methoden erkennt, die jedes Mal das gleiche Ergebnis liefern und nur einmal am Anfang einer Schleife ausgeführt werden müssen?

Answer 1

Das JIT wird, soweit ich das beurteilen kann, dies nur erkennen, wenn es sich um eine relativ einfache Inline-Methode handelt. Davon abgesehen ist es sehr einfach für einen Programmierer, diese Fälle zu erkennen, und es ist ein schweres Problem für einen JIT-Compiler zu erkennen. Vorzugsweise sollten Sie final int verwenden, um Ergebnisse von großen Methoden zwischenzuspeichern, da der JIT sehr leicht erkennen kann, dass sich der Wert nicht ändern kann, und sogar Array-Zugriffsprüfungen zur Beschleunigung von Schleifen entfernen kann.

So etwas wie

int[] arr = new int[ 10 ]; 
for(int i = 0; i < arr.length; i++) { 
    //... 
} 

oder

List<String> list = Arrays.asList(new String[] { ... }); 
for(int i = 0; i < list.size(); i++) { 
    //... 
} 

wahrscheinlich sehr leicht durch den JIT optimiert werden kann. Andere Loops, die große oder komplizierte Methoden aufrufen, können nicht ohne weiteres den gleichen Wert zurückgeben, aber Methoden wie size() könnten wahrscheinlich inline oder sogar vollständig entfernt werden.

Schließlich mit for-jeder Schleifen auf Arrays. Sie sind zu der ersten Schleife verfallen, die ich im Fall von Arrays geschrieben habe, und können auch leicht optimiert werden, um die schnellste Schleife zu erzeugen. Obwohl for-each auf Nicht-Arrays schleift, bevorzuge ich es, wenn es um schnelle Schleifen geht, da diese in Iterator-Schleifen zerfallen und nicht die zweite Schleife, die ich gepostet habe. Dies gilt nicht für LinkedList, da ein Iterator schneller ist als get() aufgrund von O (n) traversal.

Dies ist alles Spekulation darüber, was das JIT tun könnte, um eine Schleife zu optimieren. Es ist wichtig zu wissen, dass das JIT nur etwas optimiert, das die resultierenden Effekte nicht verändern kann. Die Dinge einfach zu halten, wird die Arbeit des JITs viel einfacher machen. Wie mit dem endgültigen Keyword. Die Verwendung von finalen Werten oder Methoden ermöglicht es dem JIT, leicht zu beweisen, dass sich nichts ändert und inline wie verrückt werden kann. Das ist die wichtigste Optimierung des JIT, Inlining. Machen Sie diesen Job einfach und das JIT hilft Ihnen im großen Stil.

Hier ist eine link Diskussion Schleife Optimierungen, wo das JIT kann nicht immer eine Schleife optimieren, wenn es nicht beweisen kann, dass die Optimierung nichts ändert.

Answer 2

Ich glaube, es liegt an Ihnen, als Programmierer, Fälle zu identifizieren, in denen die Obergrenze Ihrer for-loop im laufenden Betrieb berechnet werden muss und sie entsprechend zu adressieren.

Unter der Annahme, dass der Wert von n nicht auf irgendeine Operation abhängt, die innerhalb der Schleife ausgeführt wird, persönlich, würde ich es als

geschrieben bevorzugen

int n = someMethod(); 
for (int i = 0; i < n; i++); 

, weil es die häufigste Art von for-loop bewahrt, während eindeutig definiert, die obere Grenze.