différence multiThreading entre joindre et attendre, notifier

Question

Je n'ai pas travaillé dans multithreading, quelle est la différence entre joindre et attendre, notifier la méthode? la différence est-elle seulement limitée pour obtenir lock et s'abstenir d'autres threads d'y accéder ou existe-t-il d'autres cas d'utilisation?

Pourquoi devrais-je aller pour wait et notify dans multithreading quand join peut être utilisé pour l'achèvement de l'exécution thread?

Il serait utile que des exemples en temps réel ont été fournis

Answer 1

La méthode join() attend un fil à mourir. Alors que wait() et notify() sont utilisés pour la communication inter-thread. En d'autres termes, ces méthodes vont bloquer le thread jusqu'à ce que certaines conditions soient remplies.

Answer 2

La méthode join (de classe Thread) attendre un fil mourir:

Waits pour ce fil à mourir.

Les méthodes wait, notify, notifyAll ne sont pas liées à la fin de l'exécution d'un thread.

La méthode wait:

Causes du thread en cours d'attendre un autre thread appelle la méthode ou la méthode notifyAll() notify() pour cet objet.

https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#wait()

Méthodes notify et notifyAll sont utilisés pour réveiller un fil de couchage:

sillages un seul thread qui attend sur l'écran de cet objet.

---

Une utilisation courante de wait avec notify accède à une ressource partagée. Lorsque la ressource n'est pas disponible, le consommateur attend sur le moniteur. Lorsque le producteur crée la ressource, il notifie (ou notifyAll) d'éveiller le (ou les) thread (s) en attente de cette ressource.

Une utilisation courante de join bloque le thread principal jusqu'à ce qu'un thread de configuration ait terminé son activité avant de continuer.

Answer 3

join(): Attend la mort de ce fil. La méthode join permet à un thread d'attendre l'achèvement d'un autre. Si t est un objet de discussion dont le fil est en cours d'exécution,

t.join(); 

provoque le thread en cours pour mettre en pause l'exécution jusqu'à ce que le fil de t se termine.

wait(): provoque le thread en cours d'attendre jusqu'à ce qu'un autre thread invoque la méthode notify() ou la méthode notifyAll() pour cet objet.

notify(): Réveille un seul thread qui attend sur le moniteur de cet objet. Si des threads attendent sur cet objet, l'un d'eux est choisi pour être éveillé.

notifyAll(): Réveille tous les threads en attente sur le moniteur de cet objet. Un thread attend sur le moniteur d'un objet en appelant l'une des méthodes d'attente.

Référez-vous aux messages ci-dessous pour plus de détails.

Difference between wait() and sleep()

Difference between Synchronized block with wait/notify and without them?

Exemples:

A simple scenario using wait() and notify() in java

work-with-wait-notify-and-notifyall

Answer 4

Cette implémentation utilise une boucle de this.wait appels conditionnés sur this.isAlive. Lorsqu'un thread se termine, la méthode this.notifyAll est appelée . Il est recommandé aux applications de ne pas utiliser wait, notify ou notifyAll sur les instances Thread.

La bonne façon d'attendre un Thread de mettre fin (et le nettoyage) est join().

La documentation vous recommande ne pas utiliserwait(), notify() ou notifyAll() sur les instances Thread.

À mon humble avis, c'était une erreur d'ajouter un moniteur à java.lang.Object. Il est totalement hors de propos pour la plupart des classes, gonfle les implémentations et entraîne une utilisation inappropriée.

La possibilité de déclarer les méthodes synchronized était également une erreur. Il tend à allonger les sections critiques et si vraiment nécessaire (ce n'est pas le cas) pourrait être restreint à une classe java.lang.Synchronizable (ou des classes implémentant cela comme une interface) plutôt que de gonfler la hiérarchie des classes.