Comment peut "while (i == i);" être une boucle non infinie dans une seule application threadée?

J'ai juste une question à laquelle je ne peux pas répondre.

Supposons que vous ayez cette définition de boucle en Java:

while (i == i) ;

Quel est le type iet la valeur de isi la boucle n'est pas une boucle infinie et que le programme n'utilise qu'un seul thread ?

double i = Double.NaN;

L'API pour Double.equals () précise la réponse: "Double.NaN == Double.NaN a la valeur false". Ceci est développé dans la spécification du langage Java sous " Types, formats et valeurs à virgule flottante ":

NaNest non ordonnée, de sorte que les opérateurs de comparaison numérique <, <=, >et >= retour falsesi l' une ou les deux opérandes sont NaN. L'opérateur d'égalité ==retourne falsesi l'un des opérandes est NaN, et l'opérateur d'inégalité !=retourne truesi l'un des opérandes est NaN. En particulier, x!=xest truesi et seulement si xestNaN , et (x<y) == !(x>=y)sera falsesi xou yest NaN.

La valeur de iest alors Invalid. "Pas un nombre".

Après quelques recherches sur Google, j'ai découvert que vous POUVEZ avoir NaN (Not a Number) en Java! Ainsi, un nombre à virgule flottante est le type de données et la valeur est NaN. Voir ici

double i = Double.NaN;

NaN n'est égal à rien, y compris lui-même.

float i = Float.NaN;
while(i == i) ;
System.out.println("Not infinite!");

Je ne suis pas sûr, mais je crois que (i == i) n'est pas une opération atomique dans un processus multithread, donc si la valeur de i sera modifiée par un autre thread entre les poussées de sa valeur à empiler sur le thread exécutant la boucle, alors cette condition peut être faux.

Depuis que d'autres ont dit que c'était NaN, je me suis intéressé à l'implémentation officielle (JDK 6) de Double.isNaN, et voici:

/**
 * Returns <code>true</code> if the specified number is a
 * Not-a-Number (NaN) value, <code>false</code> otherwise.
 *
 * @param   v   the value to be tested.
 * @return  <code>true</code> if the value of the argument is NaN;
 *          <code>false</code> otherwise.
 */
static public boolean isNaN(double v) {
    return (v != v);
}

Considérez Nan comme l'équivalent d'une exception mais utilise une valeur magique dans un calcul. Parce qu'un calcul a échoué - par exemple, racine carrée d'un négatif, diviser par zéro, etc. - cela n'a aucun sens de les comparer à autre chose. Après tout, si diviser par zéro est un nan, est-ce équivalent à la racine carrée de -2 ou à la racine carrée de -3?

Nan permet un calcul qui comprend une étape qui renvoie une réponse invalide à terminer sans introduire d'exceptions supplémentaires. Pour vérifier que la réponse est la valeur, testez simplement la non-nandness (c'est un mot sinon je le sache) via Float.isNan () o équivalent.

J'ajouterais

float i = Float.NaN;

aussi bien que

double i = Double.NaN;

Une astuce courante dans ce genre de questions consiste à supposer que i est un entier. D'autres hypothèses courantes pourraient être que s est une chaîne, x, y sont un double, ch est un caractère, b est un octet, etc. Si vous voyez une question comme celle-ci, vous pouvez parier que «i» n'est pas son type attendu.

Une question similaire est; Cela ne boucle jamais, qu'est-ce que 'x'

while(x == x && x != x + 0) { }

Une autre question que j'aime bien est; Cette boucle est une boucle infinie, quelles sont les valeurs possibles de x. (: J'en compte douze :)

while(x != 0 && x == -x) { }

Je sais que c'est une question Java, mais considérer la question pour d'autres langages est intrigant.

En C, un type simple tel que 'int' pourrait présenter un comportement 'se terminer avant que l'univers ne devienne froid' si 'i' était déclaré comme volatile (le compilateur serait donc forcé de faire deux lectures de 'i' pour chaque itération) et si «i» était réellement en mémoire où quelque chose d'autre pourrait l'affecter. Ensuite, la boucle se terminait lorsque «i» changeait entre les deux lectures d'une seule itération. ( Ajouté : un endroit possible - dans un micro-ordinateur où 'i' est en fait situé à l'adresse d'un port d'E / S, peut-être connecté à un capteur de position. Ce serait plus plausible si 'i' était une variable de pointeur ( un pointeur vers la mémoire volatile) et l'instruction était ' while (*i == *i);'.)

Comme en témoignent d'autres réponses, en C ++, l'opérateur '==' peut être fourni par l'utilisateur si i est d'une classe définie par l'utilisateur, donc tout est possible.

Un peu comme NaN, dans un langage basé sur SQL, la boucle ne serait pas infinie si la valeur de i était NULL; cependant, toute valeur non NULL rendrait la boucle infinie. C'est un peu comme Java, où n'importe quel nombre (par opposition à NaN) rend la boucle infinie.

Je ne vois pas que la construction ait une utilité pratique, mais c'est une question triviale intéressante.

J'ai été surpris de ne pas voir cette solution:

while (sin(x) == sin(x)) //probably won't eval to true

En réponse à un commentaire, essayez d'exécuter ceci:

double x = 10.5f;
assert (x == asin(sin(x)));

x devrait toujours égaler l'arc sinus (sin (x)) en théorie, mais en pratique ce n'est pas le cas.

Pas une boucle infinie, un fil :)

import static B.*;
public class A {
    public static void main(String[] args) {
        System.out.println("Still Running");
        while (i == i) ;
    }
}


public class B {

    public static int i;
    static {
        System.exit(0);
    }
}

i == in'est pas atomique. Prouvé par un tel programme:

static volatile boolean i = true;
public static void main(String[] args) throws InterruptedException
{
    new Thread() {
        @Override
        public void run() {
            while (true) {
                i = !i;
            }
        }
    }.start();

    while (i == i) ;
    System.out.println("Not atomic! i: " + i);
}

Mise à jour Voici un autre exemple de boucle non infinie (aucun nouveau thread n'est créé).

public class NoNewThreads {
    public static void main(String[] args) {
        new NoNewThreads();
        System.gc();
        int i = 500;
        System.out.println("Still Running");
        while (i == i) ;
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        Thread.sleep(1000);
        System.exit(0);
    }
}