¿Por qué esperar hilo java trabajo () sólo con límite de tiempo aquí?

Question

Estoy tratando de familiarizarse con las hebras Java para el SCJP y que tenía una pregunta.

En el siguiente código escrito i simplemente creadas:  dos con Runnables un almacenamiento de datos común (una matriz) y un método de escritura sincronizada () para llenar con datos dejando sucesivamente una carta como una marca para cada Ejecutable (A y B) en secuencia.

Sé que el código es áspero y podría estar mejor escrito, pero yo estaba buscando la moral de los hilos.

Así que ahora cuando lo ejecuto, nunca termina y los resultados se detiene en:

Sigue siendo bueno. A0.

Pero cuando cambio wait () para esperar (100) funciona muy bien el conteo de 0 a 9 y se termina normalmente. Podría alguien explicar la razón detrás de esto por favor?

Gracias.

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

Sus hilos son cada uno espera y notificar objetos separados - por lo que no se están comunicando entre sí en absoluto. Si usted quiere que liberan eficazmente entre sí, que van a necesitar un compartida del supervisor para sincronizar, en espera y notificar.

Se trata de "trabajo" cuando se especifica un tiempo de espera porque está convirtiendo efectivamente la llamada espera en una llamada de sueño ... aún nada está realmente esperando / notificación de forma útil, porque los dos hilos todavía están tratando con monitores separados.

Answer 2

los objetos no están trabajando en mismo monitor.

tiene que mover bien la espera () y notify () al mismo objeto como: http://www.java-samples.com/showtutorial.php?tutorialid= 306

o puede notificar al objeto de destino: http://www.linuxtopia.org/online_books/programming_books/thinking_in_java/TIJ315_016. htm

cuando se establece espera (100). va a configurar un tiempo de espera. y sin duda despertará después de 100 ms.