À l'aide de join() vs wait() thread java

J'ai besoin de faire de la séquence de threads. Ils ont besoin pour commencer dans l'ordre comme ceci:

A then B then C and finally D.

Lorsque D est fini alors C peut terminer puis B puis A.

Dans cette situation, ce qui est le mieux à utiliser join() fils ou wait()? et pourquoi?

Mon fils besoin pour démarrer et imprimer le message Hello I'm thread a/b/c/d et quand ils ont fini, ils ont besoin d'imprimer I'm finished a/b/c/d.

  • Les deux choses ne sont pas vraiment liés.
  • Je suppose que vous essayez de suspendre l'exécution d'un thread.. s'il vous Plaît aller à travers Oracle java tutoriel sur les Threads docs.oracle.com/javase/tutorial/essential/concurrency/...
  • pouvez-vous explane moi qui? Que dois-je utiliser dans ce cas peut-être quelque chose d'autre?
  • Si vous avez des quatre fils qui ne sont pas "autorisés" à faire les choses jusqu'à ce qu'une certaine condition dans les autres threads, alors vous ne devriez probablement pas être le multithreading.
  • je suppose que cela va juste pour dormir pendant un certain temps, mais je veux attendre jusqu'à ce que D est terminé, puis ensuite reste d'entre eux peuvent cesser de fumer.
  • Êtes-vous sûr que votre exemple est correct? Votre sortie semble être erronée.
  • ma tâche me dit de faire ce programme. :/ Je suis en train d'apprendre les threads et d'essayer de comprendre cela.
  • Je voudrais utiliser join() parce que quand vous wait(), vous envoyez un message avec "Im done", et puis arrêtez le fil. join() fait pour vous.

InformationsquelleAutor njamanjam | 2013-06-06
  1. 6

    Depuis que vous êtes en attente pour l '"autre" thread terminer (c'est à dire terminer l'exécution), join() serait le meilleur choix.

    La javadoc de join() dit simplement: Attend à ce que le thread de mourir.

    Le mécanisme est alors relativement simple:

            @Override
        public void run() {
            System.out.println("Hello I'm thread " + getName());
            if (otherThread != null) {
                while (otherThread.isAlive()) {
                    try {
                        otherThread.join();
                    } catch (InterruptedException e) {
                        //ignore
                    }
                }
            }
            System.out.println("I'm finished " + getName());
        }

    À expliquer: vous devez disposer d'une référence à la otherThread. Donc a se réfère à b, b se réfère à c, c se réfère à d et d ne fait pas référence à toute otherThread (c'est nul).

    La déclaration otherThread.join() attend l'autre thread complet. Il est enveloppé dans une boucle depuis join() pouvez jeter InterruptedException (bien que rarement dans la pratique).

    Espère que cette aide, bonne chance.

    • otherThread.join() sera lui-même vérifier otherthread.isAlive(), ce code est redondant et pas nécessaire - grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/...
    • comme mentionné dans le Javadoc pour les blocs protégés - Note: Always invoke wait inside a loop that tests for the condition being waited for. Don't assume that the interrupt was for the particular condition you were waiting for, or that the condition is still true. , je pense que sa mise en oeuvre est à droite.
    • Ah! comme si... je vous remercie @yadav_vi, a été utile
    • J'ai essayé ceci, mais cela n'a pas fonctionné. la séquence de départ et de finition était différente à chaque fois.
    InformationsquelleAutor vikingsteve
  2. 9

    En gardant à l'esprit que join et wait faire des choses très différentes et ne sont pas vraiment liés, et ayant également à l'esprit que l'exemple que vous avez donné est vraiment, vraiment étrange, quel que soit le choix pourrait être celui que vous cherchez.

    join est probablement le choix le plus facile. Le thread appelant join va attendre jusqu'à ce que l'autre thread a fini de l'exécution. Ainsi, chaque thread dans ce cas devra contenir une référence à la prochaine fil, et il va appeler join droite avant l'impression "je suis fini". Si votre classe pourrait ressembler à ceci:

    class JoiningThread extends Thread {
    //NOTE: UNTESTED!

    private String name;
    private Thread nextThread;

    public JoiningThread(String name) {
        this(name, null);
    }

    public JoiningThread(String name, Thread other) {
        this.name = name;
        this.nextThread = other;
    }

    public String getName() {
        return name;
    }

    @Override
    public void run() {
        System.out.println("Hello I'm thread ".concat(getName()));
        if (nextThread != null) {
            while(nextThread.isAlive()) {
                try {
                    nextThread.join();
                } catch (InterruptedException e) {
                    //ignore this
                }
            }
        }
        System.out.println("I'm finished ".concat(getName()));
    }
}

    Et la méthode principale pourrait être:

    public static void main(String[] args) {
    Thread d = WaitingThread("d");
    Thread c = WaitingThread("c", d);
    Thread b = WaitingThread("b", c);
    Thread a = WaitingThread("a", b);

    a.start();
    b.start();
    c.start();
    d.start();

    try {
        a.join();
    } catch (InterruptedException e) {}
}

    Ce wait n'est la suspension de l'exécution d'un thread jusqu'à ce que notify ou notifyAll est appelé. Afin de mettre en œuvre cette idée avec wait, vous avez besoin chaque thread pour contenir une référence au fil avant il. La stratégie est pour le run méthode pour terminer par un appel à wait, suivi par un appel à notify le thread précédent que l'exécution est terminée. Si votre classe pourrait ressembler à quelque chose comme ceci:

    class WaitingThread extends Thread {
    //NOTE: UNTESTED!

    private Thread previousThread;
    private String name;

    public WaitingThread(String name) {
        this(name, null);
    }

    public WaitingThread(String name, Thread other) {
        this.name = name;
        this.previousThread = other;
    }

    public String getName() {
        return name;
    }

    @Override
    public void run() {
        System.out.println("Hello I'm thread ".concat(getName()));
        //Do other things if required

        //Wait to be woken up
        while(true) {
            synchronized(this) {
                try {
                    wait();
                    break;
                } catch (InterruptedException e) {
                    //ignore this
                }
            }
        }

        System.out.println("I'm finished ".concat(getName()));

        //Wake up the previous thread
        if (previousThread != null) {
            synchronized(previousThread) {
                previousThread.notify();
            }
        }
    }
}

    Et la main méthode qui met tout en place à partir de la thread principale pourrait être:

    public static void main(String[] args) {
    Thread a = WaitingThread("a");
    Thread b = WaitingThread("b", a);
    Thread c = WaitingThread("c", b);
    Thread d = WaitingThread("d", c);

    a.start();
    b.start();
    c.start();
    d.start();

    while(true) {
        //wake up d once it goes to sleep
        if (d.isAlive()) {
            d.notify();
        }
    }
}
    InformationsquelleAutor Henry Keiter
  3. 3

    La join() méthode est utilisée pour attendre qu'un thread pour achever l'exécution. Le join() méthode d'une instance de Thread peut être utilisé pour "rejoindre" le début d'un thread d'exécution à la fin d'un autre thread d'exécution afin qu'un thread ne va pas commencer à courir jusqu'à ce qu'un autre thread est terminé. Si join() est appelée sur une instance de Thread, le thread en cours d'exécution bloquera jusqu'à ce que le Thread instance a fini de s'exécuter.

    Un exemple de join()

    La wait() méthode est utilisée pour attendre une notification sera envoyée sur un objet. Les deux conditions sont assez distinctif.

    Un exemple et une explication plus détaillée de wait()

    • que pensez-vous est mieux join() ou wait() ?
    • Ni l'un est "mieux"; les deux ne sont pas vraiment comparables.
    • Ouais l'exemple que vous donnez dans la question la plus étrange...
    InformationsquelleAutor Joetjah
  4. 1

    Je voudrais faire de cette façon

    public class Test1 extends Thread {
    static Object lock = new Object();
    static int n;
    int i;
    String name;

    Test1(String name, int i) {
        this.name = name;
        this.i = i;
    }

    @Override
    public void run() {
    try {
        synchronized (lock) {
            while (i != n) {
                lock.wait();
            }
            System.out.println(name + " started");
            n++;
            lock.notifyAll();
        }
        synchronized (lock) {
            while (i != n - 4) {
                lock.wait();
            }
            System.out.println(name + " finished");
            n++;
            lock.notifyAll();
        }
    } catch (InterruptedException e) {
    }
    }

    public static void main(String[] args) throws Exception {
        new Test1("a", 0).start();
        new Test1("b", 1).start();
        new Test1("c", 2).start();
        new Test1("d", 3).start();
    }
}

    sortie

    a started
b started
c started
d started
a finished
b finished
c finished
d finished
    InformationsquelleAutor Evgeniy Dorofeev