Warum geht dies in eine Endlosschleife?

Ich habe folgenden Code:

public class Tests {
    public static void main(String[] args) throws Exception {
        int x = 0;
        while(x<3) {
            x = x++;
            System.out.println(x);
        }
    }
}

Wir wissen, dass er nur x++oder hätte schreiben sollen x=x+1, aber x = x++darauf sollte er sich zuerst selbst zuschreiben xund später erhöhen. Warum geht es xweiter 0als Wert?

--aktualisieren

Hier ist der Bytecode:

public class Tests extends java.lang.Object{
public Tests();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[])   throws java.lang.Exception;
  Code:
   0:   iconst_0
   1:   istore_1
   2:   iload_1
   3:   iconst_3
   4:   if_icmpge   22
   7:   iload_1
   8:   iinc    1, 1
   11:  istore_1
   12:  getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   15:  iload_1
   16:  invokevirtual   #3; //Method java/io/PrintStream.println:(I)V
   19:  goto    2
   22:  return

}

Ich werde über die Anweisungen lesen, um zu versuchen zu verstehen ...

Hinweis : Ursprünglich habe ich in dieser Antwort zur Veranschaulichung C # -Code angegeben, da Sie mit C # intParameter als Referenz mit dem refSchlüsselwort übergeben können. Ich habe beschlossen, es mit tatsächlichem legalem Java-Code zu aktualisieren, indem MutableIntich die erste Klasse verwende, die ich bei Google gefunden habe, um ungefähr zu wissen, was refin C # funktioniert. Ich kann nicht wirklich sagen, ob das hilft oder die Antwort verletzt. Ich werde sagen, dass ich persönlich nicht so viel Java-Entwicklung gemacht habe; Soweit ich weiß, könnte es viel idiomatischere Möglichkeiten geben, diesen Punkt zu veranschaulichen.

Wenn wir eine Methode aufschreiben, die das Äquivalent zu dem x++tut, was sie tut, wird dies möglicherweise klarer.

public MutableInt postIncrement(MutableInt x) {
    int valueBeforeIncrement = x.intValue();
    x.add(1);
    return new MutableInt(valueBeforeIncrement);
}

Recht? Inkrementieren Sie den übergebenen Wert und geben Sie den ursprünglichen Wert zurück: Dies ist die Definition des Nachinkrementierungsoperators.

Lassen Sie uns nun sehen, wie sich dieses Verhalten in Ihrem Beispielcode auswirkt:

MutableInt x = new MutableInt();
x = postIncrement(x);

postIncrement(x)macht was? Inkremente x, ja. Und dann gibt , was x war vor dem Zuwachs . Dieser Rückgabewert wird dann zugewiesen x.

Die Reihenfolge der zugewiesenen Werte xist also 0, dann 1, dann 0.

Dies könnte noch deutlicher werden, wenn wir das Obige neu schreiben:

MutableInt x = new MutableInt();    // x is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
x = temp;                           // Now x is 0 again.

Ihre Fixierung auf die Tatsache, dass, wenn Sie xauf der linken Seite der obigen Zuordnung durch y"Sie können sehen, dass es zuerst x erhöht und später y zuschreibt", mich verwirrt erscheinen. Es ist nicht xdas, was zugewiesen wird y; Dies ist der Wert, der zuvor zugewiesen wurdex . Das Injizieren unterscheidet ydie Dinge nicht von dem obigen Szenario. Wir haben einfach:

MutableInt x = new MutableInt();    // x is 0.
MutableInt y = new MutableInt();    // y is 0.
MutableInt temp = postIncrement(x); // Now x is 1, and temp is 0.
y = temp;                           // y is still 0.

Es ist also klar: x = x++Ändert den Wert von x effektiv nicht. Es bewirkt immer, dass x die Werte x ₀ , dann x ₀ + 1 und dann wieder x ₀ hat.

Update : Damit Sie nicht bezweifeln, dass xzwischen dem Inkrementierungsvorgang und der Zuweisung im obigen Beispiel jemals 1 "zugewiesen" wird, habe ich eine kurze Demo zusammengestellt, um zu veranschaulichen, dass dieser Zwischenwert tatsächlich "existiert", obwohl dies der Fall ist Niemals auf dem ausführenden Thread "gesehen" werden.

Die Demo ruft x = x++;in einer Schleife auf, während ein separater Thread den Wert von kontinuierlich xan die Konsole druckt .

public class Main {
    public static volatile int x = 0;

    public static void main(String[] args) {
        LoopingThread t = new LoopingThread();
        System.out.println("Starting background thread...");
        t.start();

        while (true) {
            x = x++;
        }
    }
}

class LoopingThread extends Thread {
    public @Override void run() {
        while (true) {
            System.out.println(Main.x);
        }
    }
}

Unten finden Sie einen Auszug aus der Ausgabe des obigen Programms. Beachten Sie das unregelmäßige Auftreten von Einsen und Nullen.

Hintergrund-Thread starten ...
0
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1

x = x++ funktioniert folgendermaßen:

• Zuerst wird der Ausdruck ausgewertet x++. Die Auswertung dieses Ausdrucks erzeugt einen Ausdruckswert (der der Wert xvor dem Inkrement ist) und Inkremente x.
• Später weist es den Ausdruckswert zu xund überschreibt den inkrementierten Wert.

Die Reihenfolge der Ereignisse sieht also wie folgt aus (es handelt sich um einen tatsächlich dekompilierten Bytecode, wie er von javap -cmit meinen Kommentaren erstellt wurde):

   8: iload_1 // Den aktuellen Wert von x im Stapel speichern
   9: iinc 1, 1 // Inkrementiere x (ändert den Stapel nicht)
   12: istore_1 // Schreibe einen Erinnerungswert vom Stapel nach x

Zum Vergleich x = ++x:

   8: iinc 1, 1 // Inkrementiere x
   11: iload_1 // Wert von x auf Stapel stapeln
   12: istore_1 // Pop-Wert vom Stapel auf x

Dies geschieht, weil der Wert von xüberhaupt nicht erhöht wird.

x = x++;

ist äquivalent zu

int temp = x;
x++;
x = temp;

Erläuterung:

Schauen wir uns den Bytecode für diese Operation an. Betrachten Sie eine Beispielklasse:

class test {
    public static void main(String[] args) {
        int i=0;
        i=i++;
    }
}

Wenn wir nun den Klassen-Disassembler ausführen, erhalten wir:

$ javap -c test
Compiled from "test.java"
class test extends java.lang.Object{
test();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_0
   1:    istore_1
   2:    iload_1
   3:    iinc    1, 1
   6:    istore_1
   7:    return
}

Jetzt ist die Java-VM stapelbasiert, was bedeutet, dass für jede Operation die Daten auf den Stapel übertragen werden und aus dem Stapel die Daten herausspringen, um die Operation auszuführen. Es gibt auch eine andere Datenstruktur, normalerweise ein Array zum Speichern der lokalen Variablen. Die lokalen Variablen erhalten IDs, die nur die Indizes für das Array sind.

Schauen wir uns die Mnemonik in main()Methode an:

• iconst_0: Der konstante Wert 0 wird auf den Stapel übertragen.
• istore_1: Das oberste Element des Stapels ausgeklappt ist und in dem lokalen Variable mit Index gespeichert ist, 1
  der ist x.
• iload_1: Der Wert an der Stelle 1, deren Wert x ist 0, wird in den Stapel verschoben.
• iinc 1, 1: Der Wert am Speicherort 1wird um erhöht 1. So wird xjetzt 1.
• istore_1: Der Wert oben im Stapel wird im Speicherort gespeichert 1. Das ist 0dem x Überschreiben seines inkrementierten Wertes zugeordnet.

Daher xändert sich der Wert von nicht, was zur Endlosschleife führt.

1. Die Präfixnotation erhöht die Variable, BEVOR der Ausdruck ausgewertet wird.
2. Die Postfix-Notation wird NACH der Ausdrucksauswertung erhöht.

" =" Hat jedoch eine niedrigere Operatorrangfolge als " ++".

Also x=x++;sollte wie folgt bewertet werden

1. x für den Einsatz vorbereitet (ausgewertet)
2. x erhöht
3. Vorheriger Wert von xzugewiesen an x.

Keine der Antworten war genau richtig, also geht es weiter:

Wenn Sie schreiben int x = x++, weisen Sie nicht xzu, dass es sich um den neuen Wert handelt, xsondern um den Rückgabewert des x++Ausdrucks. Was zufällig der ursprüngliche Wert von ist x, wie in Colin Cochranes Antwort angedeutet .

Testen Sie zum Spaß den folgenden Code:

public class Autoincrement {
        public static void main(String[] args) {
                int x = 0;
                System.out.println(x++);
                System.out.println(x);
        }
}

Das Ergebnis wird sein

0
1

Der Rückgabewert des Ausdrucks ist der Anfangswert von x, der Null ist. Aber später, wenn xwir den Wert von lesen , erhalten wir den aktualisierten Wert, das heißt einen.

Es wurde bereits von anderen gut erklärt. Ich füge nur die Links zu den relevanten Java-Spezifikationsabschnitten hinzu.

x = x ++ ist ein Ausdruck. Java folgt der Auswertungsreihenfolge . Zuerst wird der Ausdruck x ++ ausgewertet, der x erhöht und den Ergebniswert auf den vorherigen Wert von x setzt . Dann wird das Ausdrucksergebnis der Variablen x zugewiesen . Am Ende ist x wieder auf dem vorherigen Wert.

Diese Aussage:

x = x++;

bewertet wie folgt:

1. Schieben xauf den Stapel;
2. Inkrement x;
3. Pop xvom Stapel.

Der Wert bleibt also unverändert. Vergleichen Sie das mit:

x = ++x;

welches bewertet als:

1. Inkrement x;
2. Schieben xauf den Stapel;
3. Pop xvom Stapel.

Was Sie wollen ist:

while (x < 3) {
  x++;
  System.out.println(x);
}

Die Antwort ist ziemlich einfach. Es hat mit der Reihenfolge zu tun, in der die Dinge ausgewertet werden. x++gibt den Wert zurück xund erhöht sich dann x.

Folglich ist der Wert des Ausdrucks x++ist 0. Sie weisen also x=0jedes Mal in der Schleife zu. Erhöht x++diesen Wert zwar, aber das passiert vor der Zuweisung.

Von http://download.oracle.com/javase/tutorial/java/nutsandbolts/op1.html

Die Inkrementierungs- / Dekrementierungsoperatoren können vor (Präfix) oder nach (Postfix) dem Operanden angewendet werden. Das Codeergebnis ++; und ++ Ergebnis; Beides endet damit, dass das Ergebnis um eins erhöht wird. Der einzige Unterschied besteht darin, dass die Präfixversion (++ Ergebnis) den inkrementierten Wert ergibt, während die Postfixversion (Ergebnis ++) den ursprünglichen Wert ergibt . Wenn Sie nur ein einfaches Inkrementieren / Dekrementieren durchführen, spielt es keine Rolle, welche Version Sie wählen. Wenn Sie diesen Operator jedoch teilweise in einem größeren Ausdruck verwenden, kann der von Ihnen ausgewählte Operator einen signifikanten Unterschied bewirken.

Versuchen Sie zur Veranschaulichung Folgendes:

    int x = 0;
    int y = 0;
    y = x++;
    System.out.println(x);
    System.out.println(y);

Welches wird 1 und 0 drucken.

Sie erhalten effektiv das folgende Verhalten.

1. Nimm den Wert von x (der 0 ist) als "das Ergebnis" der rechten Seite
2. Erhöhen Sie den Wert von x (also ist x jetzt 1)
3. Weisen Sie x das Ergebnis der rechten Seite (die als 0 gespeichert wurde) zu (x ist jetzt 0).

Die Idee ist, dass der Post-Inkrement-Operator (x ++) diese fragliche Variable inkrementiert, nachdem sie ihren Wert zur Verwendung in der Gleichung zurückgegeben hat, in der sie verwendet wird.

Bearbeiten: Wegen des Kommentars etwas hinzufügen. Betrachten Sie es wie folgt.

x = 1;        // x == 1
x = x++ * 5;
              // First, the right hand side of the equation is evaluated.
  ==>  x = 1 * 5;    
              // x == 2 at this point, as it "gave" the equation its value of 1
              // and then gets incremented by 1 to 2.
  ==>  x = 5;
              // And then that RightHandSide value is assigned to 
              // the LeftHandSide variable, leaving x with the value of 5.

Sie brauchen den Maschinencode nicht wirklich, um zu verstehen, was passiert.

Nach den Definitionen:

1. Der Zuweisungsoperator wertet den Ausdruck auf der rechten Seite aus und speichert ihn in einer temporären Variablen.

   1.1. Der aktuelle Wert von x wird in diese temporäre Variable kopiert

   1.2. x wird jetzt erhöht.

2. Die temporäre Variable wird dann in die linke Seite des Ausdrucks kopiert, die zufällig x ist! Deshalb wird der alte Wert von x wieder in sich selbst kopiert.

Es ist ziemlich einfach.

Dies liegt daran, dass es in diesem Fall nie erhöht wird. x++verwendet zuerst den Wert, bevor er wie in diesem Fall inkrementiert wird:

x = 0;

Aber wenn Sie dies tun, wird ++x;dies zunehmen.

Der Wert bleibt bei 0, da der Wert 0 x++ist. In diesem Fall spielt es keine Rolle, ob der Wert von xerhöht wird oder nicht, die Zuweisung x=0wird ausgeführt. Dadurch wird der temporär inkrementierte Wert von x(der für "sehr kurze Zeit" 1 war) überschrieben .

Dies funktioniert so, wie Sie es von dem anderen erwarten. Es ist der Unterschied zwischen Präfix und Postfix.

int x = 0; 
while (x < 3)    x = (++x);

Stellen Sie sich x ++ als einen Funktionsaufruf vor, der zurückgibt, was X vor dem Inkrement war (deshalb wird es als Nachinkrement bezeichnet).

Die Operationsreihenfolge lautet also:
1: Zwischenspeichern des Werts von x vor dem Inkrementieren
2: Inkrementieren von x
3: Zurückgeben des zwischengespeicherten Werts (x vor dem Inkrementieren)
4: Rückgabewert wird x zugewiesen

Wenn sich ++ auf der rechten Seite befindet, wird das Ergebnis zurückgegeben, bevor die Zahl erhöht wird. Wechseln Sie zu ++ x und es wäre in Ordnung gewesen. Java hätte dies optimiert, um eine einzelne Operation (die Zuweisung von x zu x) anstelle des Inkrements auszuführen.

Soweit ich sehen kann, tritt der Fehler auf, weil die Zuweisung den inkrementierten Wert mit dem Wert vor der Inkrementierung überschreibt, dh das Inkrement rückgängig macht.

Insbesondere hat der Ausdruck "x ++" vor dem Inkrementieren den Wert "x" im Gegensatz zu "++ x", das nach dem Inkrementieren den Wert "x" hat.

Wenn Sie den Bytecode untersuchen möchten, sehen wir uns die drei fraglichen Zeilen an:

 7:   iload_1
 8:   iinc    1, 1
11:  istore_1

7: iload_1 # Setzt den Wert der 2. lokalen Variablen auf den Stapel
8: iinc 1,1 # erhöht die 2. lokale Variable um 1, beachten Sie, dass der Stapel unberührt bleibt!
9: istore_1 # Legt den Anfang des Stapels ab und speichert den Wert dieses Elements in der 2. lokalen Variablen
(Sie können die Auswirkungen jeder JVM-Anweisung hier lesen ).

Aus diesem Grund wird der obige Code auf unbestimmte Zeit wiederholt, während dies bei der Version mit ++ x nicht der Fall ist. Der Bytecode für ++ x sollte ganz anders aussehen, soweit ich mich an den 1.3 Java-Compiler erinnere, den ich vor etwas mehr als einem Jahr geschrieben habe. Der Bytecode sollte ungefähr so ​​aussehen:

iinc 1,1
iload_1
istore_1

Wenn Sie also nur die beiden ersten Zeilen vertauschen, wird die Semantik so geändert, dass der Wert, der nach dem Inkrement oben im Stapel verbleibt (dh der 'Wert' des Ausdrucks), der Wert nach dem Inkrement ist.

    x++
=: (x = x + 1) - 1

Damit:

   x = x++;
=> x = ((x = x + 1) - 1)
=> x = ((x + 1) - 1)
=> x = x; // Doesn't modify x!

Wohingegen

   ++x
=: x = x + 1

Damit:

   x = ++x;
=> x = (x = x + 1)
=> x = x + 1; // Increments x

Natürlich ist das Endergebnis das gleiche wie nur x++;oder ++x;in einer Zeile für sich.

 x = x++; (increment is overriden by = )

aufgrund der obigen Aussage erreicht x niemals 3;

Ich frage mich, ob die Java-Spezifikation irgendetwas enthält, das das Verhalten genau definiert. (Die offensichtliche Folge dieser Aussage ist, dass ich zu faul bin, um sie zu überprüfen.)

Beachten Sie aus Toms Bytecode, dass die Schlüsselzeilen 7, 8 und 11 sind. Zeile 7 lädt x in den Berechnungsstapel. Zeile 8 erhöht x. Zeile 11 speichert den Wert vom Stapel zurück auf x. In normalen Fällen, in denen Sie sich selbst keine Werte zuweisen, gibt es meines Erachtens keinen Grund, warum Sie nicht laden, speichern und dann erhöhen konnten. Sie würden das gleiche Ergebnis erhalten.

Angenommen, Sie hatten einen normaleren Fall, in dem Sie etwas geschrieben haben wie: z = (x ++) + (y ++);

Ob es hieß (Pseudocode zum Überspringen von technischen Details)

load x
increment x
add y
increment y
store x+y to z

oder

load x
add y
store x+y to z
increment x
increment y

sollte irrelevant sein. Jede Implementierung sollte gültig sein, würde ich denken.

Ich wäre äußerst vorsichtig beim Schreiben von Code, der von diesem Verhalten abhängt. Es sieht für mich sehr implementierungsabhängig aus, zwischen den Rissen in den Spezifikationen. Das einzige Mal, wenn es einen Unterschied macht, ist, wenn Sie etwas Verrücktes gemacht haben, wie im Beispiel hier, oder wenn zwei Threads ausgeführt wurden und von der Reihenfolge der Auswertung innerhalb des Ausdrucks abhängig waren.

Ich denke, weil in Java ++ eine höhere Priorität hat als = (Zuweisung) ... Tut es? Schauen Sie sich http://www.cs.uwf.edu/~eelsheik/cop2253/resources/op_precedence.html an ...

Der gleiche Weg, wenn Sie x = x + 1 ... + schreiben, hat eine höhere Priorität als = (Zuweisung)

Der x++Ausdruck ergibt x. Der ++Teil beeinflusst den Wert nach der Auswertung , nicht nach der Anweisung . so x = x++wird effektiv übersetzt in

int y = x; // evaluation
x = x + 1; // increment part
x = y; // assignment

Vor dem Erhöhen des Werts um eins wird der Wert der Variablen zugewiesen.

Es passiert, weil es inkrementiert ist. Dies bedeutet, dass die Variable inkrementiert wird, nachdem der Ausdruck ausgewertet wurde.

int x = 9;
int y = x++;

x ist jetzt 10, aber y ist 9, der Wert von x, bevor er erhöht wurde.

Weitere Informationen finden Sie unter Definition des Post-Inkrements .

Überprüfen Sie den folgenden Code,

    int x=0;
    int temp=x++;
    System.out.println("temp = "+temp);
    x = temp;
    System.out.println("x = "+x);

die Ausgabe wird sein,

temp = 0
x = 0

post incrementbedeutet, den Wert zu erhöhen und den Wert vor dem Inkrement zurückzugeben . Deshalb ist der Wert tempist 0. Was ist, wenn temp = iund dies in einer Schleife ist (mit Ausnahme der ersten Codezeile). genau wie in der frage !!!!

Der Inkrementoperator wird auf dieselbe Variable angewendet, der Sie zuweisen. Das bittet um Ärger. Ich bin sicher, dass Sie den Wert Ihrer x-Variablen sehen können, während Sie dieses Programm ausführen. Dies sollte klarstellen, warum die Schleife niemals endet.