Como pode "while (i == i);" ser um loop não infinito em um único aplicativo encadeado?

Acabei de receber uma pergunta que não posso responder.

Suponha que você tenha essa definição de loop em Java:

while (i == i) ;

Qual é o tipo ie o valor de ise o loop não é um loop infinito e o programa está usando apenas um thread ?

double i = Double.NaN;

A API para Double.equals () explica a resposta: "Double.NaN == Double.NaN tem o valor false". Isso é elaborado na Especificação da Linguagem Java em " Tipos, Formatos e Valores de Ponto Flutuante ":

NaNé não ordenada, de modo que o numérico operadores de comparação <, <=, >, e >= de retorno false, se um ou ambos os operandos são NaN. O operador de igualdade ==retorna falsese um dos operandos for NaNe o operador de desigualdade !=retorna truese um dos operandos for NaN. Em particular, x!=xé truese e somente se xéNaN e (x<y) == !(x>=y)será falsese xou yé NaN.

O valor de ié então inválido. "Não é um número".

Depois de pesquisar no google, descobri que você PODE ter NaN (não é um número) em Java! Portanto, um número de ponto flutuante é o tipo de dados e o valor é NaN. Veja aqui

double i = Double.NaN;

NaN não é igual a nada, inclusive a si próprio.

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

Não tenho certeza, mas acredito que (i == i) não é uma operação atômica no processo multithread, por isso, se o valor de i for alterado por outro encadeamento entre os toques de seu valor para empilhar no encadeamento que executa o loop, essa condição poderá seja falso.

Como outros disseram que é NaN, fiquei curioso sobre a implementação oficial (JDK 6) Double.isNaNe observe:

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

Pense em Nan como o equivalente à exceção, mas usa um valor mágico dentro de um cálculo. Como um cálculo falhou - por exemplo, raiz quadrada de um negativo, divida por zero etc. - não faz sentido compará-los com qualquer outra coisa. Afinal, se dividir por zero é um nan, é equivalente à raiz quadrada de -2 ou à raiz quadrada de -3?

Nan permite um cálculo que inclui uma etapa que retorna uma resposta inválida para ser concluída sem a introdução de exceções extras. Para verificar se o valor da resposta é simplesmente teste para não-incondicionalidade (isto é, se não for o caso) via Float.isNan () ou equivalente.

Eu adicionaria

float i = Float.NaN;

assim como

double i = Double.NaN;

Um truque comum nesse tipo de pergunta é na suposição de que você é um int. Outras suposições comuns podem ser s é uma String, x, y são um duplo, ch é um char, b é um byte etc. Se você vir uma pergunta como essa, pode apostar que 'i' não é o seu tipo esperado.

Uma pergunta semelhante é; Isso nunca faz loop, o que é 'x'

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

Outra pergunta de que gosto bastante é; Esse loop é um loop infinito, quais são os possíveis valores de x. (: Conto doze deles :)

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

Eu sei que essa é uma pergunta sobre Java, mas considerar a pergunta para outras linguagens é intrigante.

Em C, um tipo simples como 'int' pode exibir 'termina' antes que o universo esfrie 'comportamento' se 'i' for declarado como volátil (para que o compilador seja forçado a fazer duas leituras de 'i' para cada iteração) e se 'i' estivesse na memória, onde outra coisa poderia afetá-lo. Então o loop terminaria quando 'i' mudasse entre as duas leituras de uma única iteração. ( Adicionado : um local possível - em um microcomputador onde 'i' está realmente localizado no endereço de uma porta de E / S, talvez conectado a um sensor de posição. Seria mais plausível se 'i' fosse uma variável de ponteiro ( um ponteiro para a memória volátil) e a declaração foi 'while (*i == *i); '.)

Como evidenciado por outras respostas, em C ++, o operador '==' pode ser fornecido pelo usuário se i for de uma classe definida pelo usuário; portanto, tudo pode ser possível.

Assim como NaN, em uma linguagem baseada em SQL, o loop não seria infinito se o valor de i fosse NULL; no entanto, qualquer valor que não seja NULL tornaria o loop infinito. É como o Java, onde qualquer número (ao contrário do NaN) torna o loop infinito.

Não vejo o construto tendo nenhum uso prático, mas é uma pergunta interessante.

Fiquei surpreso ao não ver esta solução:

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

Em resposta a um comentário, tente executar o seguinte:

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

x sempre deve ser igual ao arco-seno (sin (x)) em teoria, mas na prática não é.

Não loop infinito, um segmento :)

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ão é atômico. Comprovado por esse 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);
}

Atualizar Aqui está mais um exemplo de loop não infinito (nenhum novo encadeamento é criado).

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