Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Wieviel kostet der Zugriff auf Objektattribute im Vergleich zur Erstellung von vars in Methode?
class A {
final int var = 42;
void aufrufer(){
for (int i = 0; i <= 10000000; i++){
int irgendwas = aendertSichDauernd();
rufeAuf(irgendwas);
}
}
void rufeAuf(int irgendwas){
// greife auf var zu, z.B.
irgendwas = irgendwas - var;
}
}
vs.
Java:
class B {
void aufrufer(){
for (int i = 0; i <= 10000000; i++){
int irgendwas = aendertSichDauernd();
rufeAuf(irgendwas);
}
}
void rufeAuf(int irgendwas){
final int var = 42;
irgendwas = irgendwas - var;
}
}
In Beispiel A wird var einmal initalisiert, aber dann ein paar Mio mal darauf von der Methode aus zugegriffen.
In Beispiel B wird var bei jedem Aufruf der Methode neu erzeugt und das ebenfalls ein paar Mio mal.
Es kann sein, dass das Schlüsselwort final noch weg kommt, wie würde es dann aussehen?
Theoretisch kannst du das alles Selber ausprobieren und Testen...
Guck dir mal den Befehl: 'System.currentTimeMillis();' an. wenn du den am anfang und am ende von deinem Programm einbaust und dann einfach Minus rechnest, kriegst du ja die Zeit raus, die das brauchte...
Ich denke mal sowas ist keine Frage was länger dauert oder mehr kostet sondern eine Designfrage. Wenn var eine Eigenschaft der Instanz ist dann ist es eine Instanzvariable, wenn var eine temporäre Variable ist die du in einer Methode mal brauchst um irgendwas rumzurechnen dann ist es eine lokale Variable.
okay ich hätte gesagt, dass das obere die bessere Lösung ist, vorrausgesetzt du machst var noch private und rufst die Methode rufeAuf() öfter als einmal auf.
Bei der Unteren lösung legst du die Variable halt bei jedem Methodenaufruf neu an, wärend du sie beim oberen Bespiel nur einmal anlegst, und nurnoch aufrufst...
Wenn Du den oben geposteten Code testest, sollte der zweite schneller sein. Weil der Compiler/Interpreter erkennt, dass var nur einmal benötigt wird und gar keine Variable dafür anlegt sondern es dirkt kodiert so das ein
allerdings ist der zugriff auf eine lokale variable performanter als der Zugriff auf eine Instanzvariable.
In Fällen wie diesen, ist der Compiler allerdings auch schlau genug, um beides zu optimieren.
In beiden Fällen würde der Compiler direkt mit dem Wert 42 rechnen, ohne die Variable zu benutzen.
Hier einmal der generierte Bytecode (beide Fälle erzeugen die gleiche rufeAuf methode)
Code:
iload_1 // parameter 'irgendwas' auf den Stack legen
bipush 42 // 42 auf den Stack legen
isub // zwei Werte vom Stack nehmen, subtrahieren und Ergebnis auf den Stack legen
istore_1 // Ergebnis in variable 'irgendwas' speichern
return
Ja, das habe ich gar nicht bedacht, da habt ihr alle Recht, der Compiler dürfte es in beiden Fällen wegoptimieren. Von daher wäre es aus Performancesicht egal, welche Variante man nimmt.
Wie würde es aber aussehen, wenn die Variable nicht wegoptimiert werden würde/könnte?
Wäre dann die Erzeugung einer lokalen Variabler performanter oder der Zugriff auf eine Instanzvariable?
2 Beispiele:
Java:
class C {
private int var;
void aufrufer(){
int nochwas = aendertSichAuchDauernd();
int nochwas2 = aendertSichAuchDauernd();
this.var = 42 + nochwas * nochwas2;
for (int i = 0; i <= 10000000; i++){
int irgendwas = aendertSichDauernd();
rufeAuf(irgendwas);
}
}
void rufeAuf(int irgendwas){
// greife auf var zu, z.B.
irgendwas = irgendwas - var;
}
}
Java:
class D {
void aufrufer(){
int nochwas = aendertSichAuchDauernd();
int nochwas2 = aendertSichAuchDauernd();
for (int i = 0; i <= 10000000; i++){
int irgendwas = aendertSichDauernd();
rufeAuf(irgendwas, nochwas, nochwas2);
}
}
void rufeAuf(int irgendwas, int nochwas, int nochwas2){
int var = 42 + nochwas * nochwas2;
irgendwas = irgendwas - var;
}
}
Ist das Erzeugen einer lokalen Variable schneller als der Zugriff auf eine Instanzvariable?
Das Objekt landet ja auf dem Heap, da liegt meines Wissens nach, sofern ich mich nicht irre, also auch die Instanzvariable. Die lokale Variable wird dagegen auf dem Stack erzeugt.
Letzteres könnte z.B. in einem Register landen und ersteres zu einem teuren Speicherzugriff führen, so meine Vermutung.
EDIT:
Zugegeben, die Multiplikation mit den zwei nochwas Variablen ist unschön, bzw. verfälscht das Ergebnis, im Grunde wollte ich für das Beispiel auch nur die Erzeugung einer lokalen Variable in der Methode erzwingen, damit nicht mit einer Referenz weitergerechnet wird, daher ein verbessertes Beispiel:
Java:
class E {
private int var;
void aufrufer(){
for (int i = 0; i <= 10000000; i++){
int nochwas = aendertSichAuchDauernd();
int nochwas2 = aendertSichAuchDauernd();
this.var = 42 + nochwas * nochwas2;
int irgendwas = aendertSichDauernd();
rufeAuf(irgendwas);
}
}
void rufeAuf(int irgendwas){
// greife auf var zu, z.B.
irgendwas = irgendwas - var;
}
}
Java:
class F {
void aufrufer(){
for (int i = 0; i <= 10000000; i++){
int nochwas = aendertSichAuchDauernd();
int nochwas2 = aendertSichAuchDauernd();
int irgendwas = aendertSichDauernd();
rufeAuf(irgendwas, nochwas, nochwas2);
}
}
void rufeAuf(int irgendwas, int nochwas, int nochwas2){
int var = 42 + nochwas * nochwas2;
irgendwas = irgendwas - var;
}
}
EDIT2:
Okay, die beiden Beispiele E und F sind auch nicht wirklich geeignet. Mir ist gerade aufgefallen, dass ich auf die Instanzvariable ja mehrfach in der Schleife zugreife, womit man da nicht mehr viel gegenüber der lokalen Variable in Bsp. F gewinnen würde.
Mir fällt aber gerade kein besseres bzw. anderes Beispiel ein, um das worauf ich hinaus will, etwas genauer zu konkretisieren.
Es dürfte hier für den Menschen keinen Unterschied machen, ob eine Instanzvariable oder lokale Variable geladen wird! Das liegt hier im Nanosekundenbereich. Auch weiß man nie was der Compiler macht - wie auch in dem obigen Beispiel verdeutlicht - ob er jetzt auch noch den JIT Compiler anschmeisst.
Die Frage sollte eher lauten, was ist leselicher und was macht mehr Sinn!
Wenn es sich um eine akademische Frage lautet, dann kann man sagen, dass lokale Variablen (auch Konstanten: static final) gleich schnell geladen werden (Was auch wieder auf die JVM ankommt).
Rein theoretisch dürfte der Zugriff auf eine Objektvariable teurer sein, da das Programm ja erst mal über "this" (bzw. die Objektreferenz) ermitteln muss wo das Objekt überhaupt im Speicher liegt, und dann von dort aus auf die Objektvariable zugreifen. Bei einer lokalen Variable entfällt das und es kann direkt auf den Wert zugegriffen werden.
Ansonsten würde ich Flown uneingeschränkt zustimmen. Im Zweifelsfall IMMER das schreiben was lesbarer ist. Ich kenne keinen Fall, bei dem ein Variablenzugriff ein Programm messbar ausgebremst hätte. Der Unterschied dürfte jedenfalls so gering sein, daß du ihn bestenfalls mit Profiler-Werkzeugen erkennst.
Compiler sind heutzutage wirklich verdammt gut darin, solchen Kleinkram zu optimieren. Da kommt man selbst mit handoptimiertem Assemblercode kaum noch ran. Also lieber den einfacheren, lesbareren Code schreiben, und dem Compiler die Drecksarbeit machen lassen
Das einzige was mir dazu einfällt:
"Programmers waste enormous amounts of time thinking about, or worrying about, the speed of noncritical parts of their programs, and these attempts at efficiency actually have a strong negative impact when debugging and maintenance are considered. We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%." - Don Knuth
Danke für eure Antworten. Ja, es war auch mehr eine akademische Frage falls ich mal in so eine Situation geraten sollte und ich zig Aufrufe haben dieser Art haben sollte.
Also wenn es rein akademischer Natur ist, dann würde ich es so wie die JDK-Entwickler machen. Den ganzen (globalen) Instanzkontext in lokale Variablen am Anfang holen und dann eben die Sachen bearbeiten (kann man gut in den Collectionsklassen sehen). Aber VORSICHT! die meisten haben sehr viel Ahnung was dann im Hintergrund geschehen kann und wird. Damit meine ich sie erleichtern den Compiler gewisse Sachen zu optimieren. Wann, wo und wie sowas erleichtert wird hängt ganz von der Compilerimplementierung ab und erfordert sehr viel Erfahrung und Wissen. Fazit: immer lesbaren Code schreiben und keine Optimierung selbst schreiben.
