Warum funktioniert Java-Thread wait () arbeiten nur mit Zeitlimit hier drin?

Question

Ich versuche, mit Java-Threads für die SCJP vertraut zu machen, und ich hatte eine Frage.

In dem unten geschriebenen Code i einfach erstellt: zwei Runnables mit ein gemeinsamer Datenspeicher (ein Array) und eine synchronisiertes write () Methode, um es zu füllen, mit Daten nacheinander einen Brief als eine Markierung für jede Runnable (A und B) in der Reihenfolge zu verlassen.

Ich weiß, dass der Code ist rau und besser geschrieben werden könnte, aber ich suchte die Moral der Fäden.

So, jetzt, wenn ich es laufen, es endet nie, und die Ergebnisse halten an:

Immer noch gut. A0.

Aber wenn ich warten ändern () warten (100) es funktioniert gut Zählen von 0 bis 9 und endet normalerweise. Könnte jemand den Grund, dass für mich erklären, bitte?

Danke.

public class ArrayThreads {

Object[] array = new Object[10];
boolean isA = true;

    int position = 0;

    int getIndex(){
        return position;
    }



class ThreadA implements Runnable{

            synchronized void write(String value){
                    while(!isA){
            try {
                wait();
            } catch (InterruptedException ex) {
                System.out.println("An error in" + value);
                ex.printStackTrace();
            }
        }
        array[position] = value + position;
        System.out.println(array[position]);
        position++;
        isA = !isA;
        notify();
    }

    public void run() {
        while(getIndex()<array.length){
            if (getIndex()==9) return;
            else
        write("A");}
    }
}

    class ThreadB implements Runnable{

                synchronized void write(String value){
                    while(isA){
            try {
                wait();
            } catch (InterruptedException ex) {
                System.out.println("An error in" + value);
                ex.printStackTrace();
            }
        }
        array[position] = value + position;
        System.out.println(array[position]);
        position++;
        isA = !isA;
        notify();
    }

    public void run() {
        while(getIndex()<array.length){
            if (getIndex()==9) return;
            else
        write("B");}
    }
}

    public static void main(String[] args){
        ArrayThreads threads = new ArrayThreads();
        Thread threadA = new Thread(threads.new ThreadA());
        Thread threadB = new Thread(threads.new ThreadB());
        System.out.println("Still good");

        threadB.start();
        threadA.start();
    }

}

Answer 1

Ihre Themen sind jeweils Warte- und anmelde separate Objekte - so sie nicht miteinander überhaupt in Verbindung stehen. Wenn Sie wollen, sie effektiv zu lösen, müssen sie einen shared Monitor zu synchronisieren, wartet auf und informieren.

Es ist „arbeiten“, wenn Sie ein Timeout angeben, da es effektiv ist das Warten Anruf in einen Schlaf Anruf drehen ... noch nichts wirklich wartet / Benachrichtigungs nutzbringend, weil die beiden Fäden noch mit separaten Monitoren handelt.

Answer 2

Ihre Objekte funktionieren nicht in demselben Monitor.

Sie müssen entweder die Warte bewegen () und notify () auf gleiches Objekt wie: http://www.java-samples.com/showtutorial.php?tutorialid= 306

oder Sie können das Zielobjekt informieren: http://www.linuxtopia.org/online_books/programming_books/thinking_in_java/TIJ315_016. htm

, wenn Sie warten gesetzt (100). Sie setzen ein Timeout. und auf jeden Fall wird es bis nach 100ms wecken.