Pourquoi fonctionne-t-thread java d'attente () seulement avec le temps limite ici?

Question

Je suis en train de se familiariser avec les threads Java pour la SCJP et j'avais une question.

Dans le code écrit ci-dessous i simplement créé:  deux runnables avec un stockage de données commun (une matrice) et un procédé d'écriture synchronisée () afin de le remplir avec des données successivement en laissant une lettre comme marque pour chaque Exécutable (A et B) en séquence.

Je sais que le code est rude et pourrait être mieux écrit, mais je cherchais la morale des fils.

Alors maintenant quand je le lance, il se termine jamais et les résultats arrêter à:

Toujours bon. A0.

Mais quand je change d'attente () attendre (100), il fonctionne très bien comptage de 0 à 9 et se termine normalement. Quelqu'un pourrait-il expliquer la raison derrière cela pour moi s'il vous plaît?

Merci.

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

Vos fils sont chacun attente et de notification des objets séparés - ils ne communiquent pas les uns avec les autres tout. Si vous voulez qu'ils libèrent efficacement les uns des autres, ils ont besoin d'un partagé moniteur à synchroniser, et attente sur notification.

Il est « travail » lorsque vous spécifiez un délai d'attente, car il tourne effectivement l'appel d'attente dans un appel de sommeil ... toujours rien est vraiment en attente / notification utile, parce que les deux fils sont toujours aux prises avec des moniteurs séparés.

Answer 2

vos objets ne fonctionnent pas dans la même moniteur.

vous devez déplacer soit l'attente () et notify () à un même objet comme: http://www.java-samples.com/showtutorial.php?tutorialid= 306

ou vous pouvez informer l'objet cible: http://www.linuxtopia.org/online_books/programming_books/thinking_in_java/TIJ315_016. htm

lorsque vous définissez attente (100). vous définissez un délai d'attente. et certainement il se réveillera après 100ms.