“While (i == i);” nasıl olabilir? iş parçacıklı uygulamada sonsuz olmayan bir döngü olabilir mi?

Sadece cevaplayamadığım bir sorum var.

Java'da bu döngü tanımına sahip olduğunuzu varsayalım:

while (i == i) ;

Döngü sonsuz bir döngü değilse ve program yalnızca bir iş parçacığı kullanıyorsa türü ive değeri nedir?i

double i = Double.NaN;

Double.equals () için API şu cevabı belirtir: "Double.NaN == Double.NaN, false değerine sahiptir". Java Dil Belirtimi'nde " Kayan Nokta Türleri, Biçimler ve Değerler " başlığı altında ele alınmıştır :

NaNSayısal karşılaştırma operatörleri, böylece sırasız <, <=, >ve >= geri dönüş falseya da her iki işlenen ise NaN. Eşitlik operatörü ==döner falseya işlenen ise NaN, ve eşitsizlik operatörü !=döner trueya işlenen ise NaN. Özellikle, x!=xolup trueancak ve ancak xISNaN ve (x<y) == !(x>=y)olacak falseeğer xyoksa yolduğunu NaN.

Değeri igeçersizdir. Msgstr "Sayı Değil".

Bazı googling sonra, Java NaN (değil bir sayı) olabilir öğrendim! Dolayısıyla, bir Kayan Nokta numarası Veri Türü ve Değer NaN'dir. Buraya bakın

double i = Double.NaN;

NaN kendisi dahil hiçbir şeye eşit değildir.

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

Emin değilim, ama inanıyorum (i == i) çok iş parçacıklı işlemde atomik işlem değildir, bu yüzden i değeri döngü yürütme iş parçacığına yığmak için değeri iter arasında diğer iş parçacığı tarafından değiştirilecek, o zaman bu koşul olabilir yanlış olmak.

Diğerleri NaN olduğunu söylediğinden, resmi (JDK 6) uygulamasını merak ettim ve şunları görüyorum Double.isNaN:

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

Nan'i istisnaya eşdeğer olarak düşünün, ancak hesaplamada sihirli bir değer kullanın. Bir hesaplama başarısız olduğu için (örneğin, negatifin karekökü, sıfıra bölme vb.), Bunları başka bir şeyle karşılaştırmak mantıklı değildir. Sonuçta sıfıra bölmek bir nan ise -2'nin kare köküne veya -3'ün kare köküne eşdeğerdir?

Nan, ek istisnalar getirmeden tamamlanması için geçersiz bir yanıt döndüren bir adım içeren bir hesaplamaya izin verir. Cevabın değer olduğunu doğrulamak için sadece Float.isNan () o eşdeğeri ile nandness (bu çanta değilse ben kelime) test edin.

Ekleyeceğim

float i = Float.NaN;

Hem de

double i = Double.NaN;

Bu tür soruların ortak bir hilesi, ben bir int olduğunu varsayalım. Diğer yaygın varsayımlar s olabilir bir dize, x, y bir çift, ch bir char, b bir bayt vs.

Benzer bir soru; Bu asla dönmez, 'x' nedir

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

Oldukça sevdiğim bir başka soru; Bu döngü sonsuz bir döngüdür, x'in olası değerleri nelerdir. (: On ikisini sayıyorum :)

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

Bunun bir Java sorusu olduğunu biliyorum, ancak diğer diller için soruyu düşünmek ilgi çekicidir.

C'de, 'i' geçici bir tür 'evren soğumadan önce sonlanabilir' davranışı 'i' değişken olarak bildirilirse (böylece derleyici her bir yineleme için iki 'i' okuması yapmaya zorlanacaktır) ve eğer 'i' aslında başka bir şeyin onu etkileyebileceği bellekte olsaydı. Sonra tek bir yinelemenin iki okuması arasında 'i' değiştiğinde döngü sonlanır. ( Eklendi : olası bir yer - 'i' nin aslında bir G / Ç bağlantı noktasının adresinde, belki de bir konum sensörüne bağlı olduğu bir mikro bilgisayarda. 'İ' bir işaretçi değişkeni olsaydı daha mantıklı olurdu ( geçici belleğe bir işaretçi) ve ifade ' while (*i == *i);' idi.)

Diğer cevapların kanıtladığı gibi, C ++ 'da, kullanıcı tarafından tanımlanmış bir sınıftaysa, kullanıcı tarafından' == 'operatörü sağlanabilir, bu nedenle her şey mümkün olabilir.

Bunun yerine, NaN gibi, SQL tabanlı bir dilde, i değeri NULL olsaydı döngü sonsuz olmazdı; ancak, NULL olmayan herhangi bir değer döngüyü sonsuz yapar. Bu, Java'ya benzer, herhangi bir sayı (NaN yerine) döngüyü sonsuz yapar.

Yapının pratik bir kullanımı olduğunu görmüyorum, ancak ilginç bir trivia sorusu.

Bu çözümü görmekten şaşırdım:

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

Bir yoruma yanıt olarak şunu çalıştırmayı deneyin:

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

x teoride her zaman arksine (sin (x)) eşit olmalıdır, fakat pratikte değildir.

Sonsuz döngü değil, bir iplik :)

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 == iatomik değildir. Böyle bir program tarafından kanıtlanmıştır:

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

Güncelleme Burada sonsuz olmayan döngüye bir örnek daha verilmiştir (yeni evre oluşturulmamıştır).

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