Perché il filo java attesa) di lavoro (solo con limite di tempo in qua?

Question

Sto cercando di acquisire familiarità con i thread Java per la SCJP e ho avuto una domanda.

Nel codice qui sotto-scritto ho semplicemente creato:  due Runnables con una memoria comune (un array) e un metodo di scrittura sincronizzato () per riempire con i dati successivamente lasciando una lettera come indicatore per ciascun Runnable (A e B) in sequenza.

So che il codice è ruvida e potrebbe essere scritta meglio ma mi cercava il morale dei fili.

Così ora quando l'eseguo, non è mai termina ed i risultati si ferma alla:

Ancora buono. A0.

Ma quando cambio di attesa () per attendere (100) funziona il conteggio appena benissimo 0-9 e termina normalmente. qualcuno potrebbe spiegare il motivo dietro che per me per favore?

Grazie.

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

Il tuo fili sono ogni attesa e notifica oggetti separati - quindi non sono comunicanti tra loro a tutti. Se si desidera loro di rilasciare in modo efficace l'un l'altro, avranno bisogno di un condiviso Monitor per sincronizzare, attesa su e notificare.

E ' "lavoro" quando si specifica un timeout perché è effettivamente girando la chiamata di attesa in una chiamata sonno ... ancora nulla è realmente in attesa / notifica utilmente, perché i due fili sono ancora alle prese con monitor separati.

Answer 2

i tuoi oggetti non stanno lavorando in stesso monitor.

è necessario spostare sia l'attesa () e notify () per lo stesso oggetto come: http://www.java-samples.com/showtutorial.php?tutorialid= 306

o è possibile notificare l'oggetto di destinazione: http://www.linuxtopia.org/online_books/programming_books/thinking_in_java/TIJ315_016. htm

quando si imposta attesa (100). si sta impostando un timeout. e sicuramente si sveglierà dopo 100ms.