¿Cómo puede "while (i == i);" ser un bucle no infinito en una sola aplicación roscada?

Acabo de recibir una pregunta que no puedo responder.

Supongamos que tiene esta definición de bucle en Java:

while (i == i) ;

¿Cuál es el tipo iy el valor de isi el ciclo no es un ciclo infinito y el programa usa solo un hilo ?

double i = Double.NaN;

La API para Double.equals () explica la respuesta: "Double.NaN == Double.NaN tiene el valor false". Esto se elabora en la Especificación del lenguaje Java en " Tipos, formatos y valores de punto flotante ":

NaNes desordenada, por lo que la numérica operadores de comparación <, <=, >, y >= de retorno falsesi uno o ambos operandos son NaN. El operador de igualdad ==regresa falsesi cualquiera de los operandos es NaN, y el operador de desigualdad !=regresa truesi cualquiera de los operandos es NaN. En particular, x!=xes truesi y solo si xesNaN , y (x<y) == !(x>=y)será falsesi xo yes NaN.

El valor de ies entonces Inválido. "No un número".

¡Después de buscar en Google, descubrí que PUEDES tener NaN (no un número) en Java! Por lo tanto, un número de Float Pointing es el Tipo de datos y el Valor es NaN. Ver aquí

double i = Double.NaN;

NaN no es igual a nada, incluso a sí mismo.

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

No estoy seguro, pero creo que (i == i) no es una operación atómica en un proceso de subprocesos múltiples, por lo que si el valor de i será cambiado por otro hilo entre las pulsaciones de su valor para apilarlo en el hilo que ejecuta el bucle, entonces esa condición puede ser falso

Como otros dijeron que era NaN, sentí curiosidad por la implementación oficial (JDK 6) de Double.isNaN, y he aquí:

/**
 * 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);
}

Piense en Nan como el equivalente de excepción, pero usa un valor mágico dentro de un cálculo. Debido a que un cálculo falló, por ejemplo, la raíz cuadrada de un negativo, dividir por cero, etc., no tiene sentido compararlos con otra cosa. Después de todo, si dividir entre cero es un nan, ¿es equivalente a la raíz cuadrada de -2 o la raíz cuadrada de -3?

Nan permite un cálculo que incluye un paso que devuelve una respuesta no válida para completar sin introducir excepciones adicionales. Para verificar que la respuesta sea un valor, simplemente pruebe la falta de agudeza (es decir, si no, la empaqueto) a través de Float.isNan () o equivalente.

yo podria agregar

float i = Float.NaN;

tanto como

double i = Double.NaN;

Un truco común en este tipo de preguntas es suponer que yo soy un int. Otros supuestos comunes pueden ser s es una cadena, x, y son dobles, ch es un carácter, b es un byte, etc. Si ve una pregunta como esta, puede apostar que 'i' no es su tipo esperado.

Una pregunta similar es; Esto nunca se repite, lo que es 'x'

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

Otra pregunta que me gusta bastante es; Este bucle es un bucle infinito, ¿cuáles son los valores posibles de x? (: Cuento doce de ellos :)

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

Sé que esta es una pregunta de Java, pero considerar la pregunta para otros idiomas es intrigante.

En C, un tipo simple como 'int' podría exhibir 'terminar antes de que el universo se enfríe' si 'i' se declara como volátil (por lo que el compilador se vería obligado a hacer dos lecturas de 'i' para cada iteración) y si 'i' estaba realmente en la memoria donde algo más podría afectarlo. Entonces el ciclo terminaría cuando 'i' cambiara entre las dos lecturas de una sola iteración. ( Agregado : un lugar posible, en una microcomputadora donde 'i' se encuentra realmente en la dirección de un puerto de E / S, quizás conectado a un sensor de posición. Sería más plausible si 'i' fuera una variable de puntero ( un puntero a la memoria volátil) y la declaración fue ' while (*i == *i);'.)

Como lo demuestran otras respuestas, en C ++, el operador puede proporcionar el operador '==' si soy de una clase definida por el usuario, por lo que cualquier cosa podría ser posible.

Al igual que NaN, en un lenguaje basado en SQL, el bucle no sería infinito si el valor de i fuera NULL; sin embargo, cualquier valor no NULL haría que el bucle sea infinito. Esto es más bien como Java, donde cualquier número (en oposición a NaN) hace que el ciclo sea infinito.

No veo que la construcción tenga ningún uso práctico, pero es una pregunta interesante.

Me sorprendió no ver esta solución:

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

En respuesta a un comentario, intente ejecutar esto:

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

x siempre debe ser igual al arcoseno (sin (x)) en teoría, pero en la práctica no lo es.

No bucle infinito, un hilo :)

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 == iNo es atómico. Probado por dicho programa:

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);
}

Actualización Aquí hay un ejemplo más de bucle no infinito (no se crean nuevos hilos).

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);
    }
}