Une boucle apparemment sans fin se termine, sauf si System.out.println est utilisé

J'avais un simple morceau de code qui était censé être une boucle sans fin car il xaugmentera toujours et restera toujours plus grand que j.

int x = 5;
int y = 9;
for (int j = 0; j < x; j++) {
   x = x + y;
}
System.out.println(y);

mais tel quel, il imprime yet ne boucle pas indéfiniment. Je ne peux pas comprendre pourquoi. Cependant, lorsque j'ajuste le code de la manière suivante:

int x = 5;
int y = 9;
for (int j = 0; j < x; j++) {
    x = x + y;
    System.out.println(y);
}
System.out.println(y);

Cela devient une boucle sans fin et je ne sais pas pourquoi. Java reconnaît-il sa boucle sans fin et l'ignore dans la première situation, mais doit-il exécuter un appel de méthode dans la seconde pour qu'il se comporte comme prévu? Confus :)

Les deux exemples ne sont pas sans fin.

Le problème est la limitation du inttype en Java (ou à peu près dans n'importe quel autre langage courant). Lorsque la valeur de xatteint 0x7fffffff, l'ajout d'une valeur positive entraînera un débordement et le xdeviendra négatif, donc inférieur à j.

La différence entre la première et la deuxième boucle est que le code interne prend beaucoup plus de temps et qu'il faudrait probablement plusieurs minutes avant que les xdébordements ne se produisent . Pour le premier exemple, cela peut prendre moins d'une seconde ou très probablement le code sera supprimé par l'optimiseur car il n'a aucun effet.

Comme mentionné dans la discussion, le temps dépendra fortement de la façon dont le système d'exploitation met en mémoire tampon la sortie, s'il sort vers l'émulateur de terminal, etc., de sorte qu'il peut être beaucoup plus élevé que quelques minutes.

Puisqu'ils sont déclarés comme int, une fois qu'il atteint la valeur maximale, la boucle se cassera car la valeur x deviendra négative.

Mais lorsque System.out.println est ajouté à la boucle, la vitesse d'exécution devient visible (car la sortie vers la console ralentira la vitesse d'exécution). Cependant, si vous laissez le 2ème programme (celui avec syso à l'intérieur de la boucle) s'exécuter assez longtemps, il devrait avoir le même comportement que le premier (celui sans syso dans la boucle).

Il peut y avoir deux raisons à cela:

1. Java optimise la forboucle et comme il n'y a aucune utilisation d' xaprès la boucle, supprime simplement la boucle. Vous pouvez vérifier cela en mettant une System.out.println(x);instruction après la boucle.

2. Il est possible que Java n'optimise pas réellement la boucle et qu'il exécute le programme correctement et finisse par xdevenir trop volumineux intet déborder. Un débordement d'entier rendra probablement l'entier xnégatif qui sera plus petit que j et il sortira donc de la boucle et affichera la valeur de y. Cela peut également être vérifié en ajoutant System.out.println(x);après la boucle.

De plus, même dans le premier cas, un débordement se produira éventuellement, ce qui le rendra dans le second cas, de sorte que ce ne sera jamais une véritable boucle sans fin.

Ce ne sont pas tous les deux des boucles infinies, initialement j = 0, tant que j <x, j augmente (j ++), et j est un entier donc la boucle fonctionnerait jusqu'à ce qu'elle atteigne la valeur maximale puis déborde (un débordement d'entier est la condition qui se produit lorsque le résultat d'une opération arithmétique, telle que la multiplication ou l'addition, dépasse la taille maximale du type entier utilisé pour le stocker.). pour le deuxième exemple, le système imprime simplement la valeur de y jusqu'à ce que la boucle se brise.

si vous cherchez un exemple de boucle sans fin, cela devrait ressembler à ceci

int x = 6;

for (int i = 0; x < 10; i++) {
System.out.println("Still Looping");
}

car (x) n'atteindrait jamais la valeur de 10;

vous pouvez également créer une boucle infinie avec une double boucle for:

int i ;

  for (i = 0; i <= 10; i++) {
      for (i = 0; i <= 5; i++){
         System.out.println("Repeat");   
      }
 }

cette boucle est infinie car la première boucle for dit i <10, ce qui est vrai donc elle entre dans la deuxième boucle for et la deuxième boucle for augmente la valeur de (i) jusqu'à ce qu'elle soit == 5. Ensuite, elle passe dans la première boucle for à nouveau parce que i <10, le processus se répète car il se réinitialise après la deuxième boucle for

C'est une boucle finie car une fois que la valeur de xdépasse 2,147,483,647(qui est la valeur maximale de an int), xelle deviendra négative et ne sera plus jsupérieure, que vous imprimiez y ou non.

Vous pouvez simplement changer la valeur de yà 100000et imprimer ydans la boucle et la boucle se cassera très bientôt.

La raison pour laquelle vous pensez qu'il est devenu infini est que le System.out.println(y);code a été exécuté beaucoup plus lentement que sans aucune action.

Problème intéressant En fait, dans les deux cas, la boucle n'est pas sans fin

Mais la principale différence entre eux est quand il se terminera et combien de temps xil faudra pour dépasser la intvaleur maximale , c'est- 2,147,483,647à-dire qu'il atteindra l'état de débordement et que la boucle se terminera.

La meilleure façon de comprendre ce problème est de tester un exemple simple et de conserver ses résultats.

Exemple :

for(int i = 10; i > 0; i++) {}
System.out.println("finished!");

Production:

finished!
BUILD SUCCESSFUL (total time: 0 seconds)

Après avoir testé cette boucle infinie, il faudra moins d'une seconde pour se terminer.

for(int i = 10; i > 0; i++) {
    System.out.println("infinite: " + i);
}
System.out.println("finished!");

Production:

infinite: 314572809
infinite: 314572810
infinite: 314572811
.
.
.
infinite: 2147483644
infinite: 2147483645
infinite: 2147483646
infinite: 2147483647
finished!
BUILD SUCCESSFUL (total time: 486 minutes 25 seconds)

Sur ce cas de test, vous remarquerez une énorme différence dans le temps nécessaire pour terminer et terminer l'exécution du programme.

Si vous n'êtes pas patient, vous penserez que cette boucle est sans fin et ne se terminera pas, mais en fait, il faudra des heures pour se terminer et atteindre l'état de débordement à la ivaleur.

Enfin, nous avons conclu après avoir mis l'instruction print dans la boucle for que cela prendrait beaucoup plus de temps que la boucle dans le premier cas sans instruction print.

Ce temps nécessaire pour exécuter le programme dépend des spécifications de votre ordinateur, en particulier de la puissance de traitement (capacité du processeur), du système d'exploitation et de votre IDE qui compile le programme.

Je teste ce cas sur:

Lenovo 2,7 GHz Intel Core i5

Système d'exploitation: Windows 8.1 64x

IDE: NetBeans 8.2

Il faut environ 8 heures (486 minutes) pour terminer le programme.

Vous pouvez également remarquer que l'incrément de pas dans la boucle for i = i + 1est un facteur très lent pour atteindre la valeur max int.

Nous pouvons changer ce facteur et accélérer l'incrémentation des pas afin de tester la boucle en moins de temps.

si nous le mettons i = i * 10et le testons:

for(int i = 10; i > 0; i*=10) {
           System.out.println("infinite: " + i);
}
     System.out.println("finished!");

Production:

infinite: 100000
infinite: 1000000
infinite: 10000000
infinite: 100000000
infinite: 1000000000
infinite: 1410065408
infinite: 1215752192
finished!
BUILD SUCCESSFUL (total time: 0 seconds)

Comme vous le voyez, c'est très rapide par rapport à la boucle précédente

cela prend moins d'une seconde pour se terminer et terminer l'exécution du programme.

Après cet exemple de test, je pense qu'il devrait clarifier le problème et prouver la validité de Zbynek Vyskovsky - la réponse de kvr000 , aussi ce sera la réponse à cette question .