Rejoignez-vous littéralement se joindre. Jetons un coup d'œil à l'explication et à la mise en œuvre de la méthode de jointure.
/ ** * attend que ce fil meure. * Le thread de l'appelant (le thread qui appelle la méthode de jointure) effectue une opération d'attente jusqu'à ce que le thread appelé (le thread sur lequel appartient la méthode de jointure) se termine et se réveille à nouveau * <p> Une invocation de cette méthode se comporte exactement de la même * manière que l'invocation * * * @throws interrompuedException * si un thread a interrompu le thread actuel. L'état * <i> interrompu </i> du thread actuel est * effacé lorsque cette exception est lancée. * / public final void join () lance InterruptedException {join (0); }Ici, jointure s'appelle
/ ** * attend au plus {@code Millis} Millionscondes pour ce fil à * mourir. Un délai d'expiration de {@code 0} signifie attendre que l'exécution du thread se termine, ou que le temps d'attente maximum spécifié est arrivé, le fil de l'appelant est à nouveau éveillé. Si le temps d'attente maximal est de 0, vous ne pouvez qu'attendre que l'exécution du thread se termine avant de pouvoir vous réveiller. * <p> Cette implémentation utilise une boucle de {@code this.wait} appelle * conditionné sur {@code this.isalive}. Au fur et à mesure qu'un thread termine la méthode * {@code this.notifyall} est invoquée. Il est recommandé que * les applications n'utilisent pas {@code wait}, {@code notify}, ou * {@code notifyall} sur les instances {@code thread}. * * * / public final synchronisé void join (long millis) lance InterruptedException {long base = System.currenttimemillis (); long maintenant = 0; if (Millis <0) {lancer un nouveau IllégalArgumentException ("La valeur de tempsort est négative"); } if (Millis == 0) {while (isAlive ()) {wait (0); }} else {while (isAlive ()) {Long Delay = Millis - Now; if (delay <= 0) {Break; } attendre (retard); maintenant = System.CurrentTimeMillis () - base; }}} On peut voir que la méthode de jointure elle-même s'implémente à travers la méthode d'attente. Il est jugé ici que si le fil est toujours en cours d'exécution, continuez d'attendre. Si l'heure spécifiée est venue ou si le thread est terminé, le code continue d'exécuter vers le bas et le thread d'appel peut exécuter la logique suivante.
Mais ici, je ne vois pas où appeler la méthode Notify ou Notifyall. S'il n'est pas appelé, le fil de l'appelant continuera à attendre. Où la méthode pour le réveiller? Grâce à la vérification, il a été constaté que lorsque le thread se terminait, la machine virtuelle Java a exécuté la méthode de sortie locale du thread.
// Fonction de sortie de thread: void javathread :: exit (bool destre_vm, exittype exit_type) {... // Cela gérera la logique de destruction liée à la jointure SUR_JOIN (this); ...} // traitera la logique de destruction liée à la jointure statique Void assey_Join (javathread * thread) {manche threadoBj (thread- witer- (thread- (thread- (); Verrouillage objectlocker (ThreadObj, Thread); thread-> clear_pending_exception (); java_lang_thread :: set_thread_status (threadObj (), java_lang_thread :: terminée); java_lang_thread :: set_thread (threadObj (), null); // Ici, nous appelons la méthode Notifyall pour réveiller le fil de fil d'attente.Notify_all (thread); thread-> clear_pending_exception (); }Cela comprendra quand le fil est éveillé. Écrivons un exemple ci-dessous pour voir l'effet.
classe publique conjointe {public static void main (String [] args) {Threadboy boy = new Threadboy (); boy.start (); } classe statique Threadboy étend Thread {@Override public void run () {System.out.println ("Boy et Girl sont prêts à faire du shopping"); Threadgirl girl = new Threadgirl (); girl.start (); essayez {girl.join (); } catch (InterruptedException e) {e.printStackTrace (); } System.out.println ("Le garçon et la fille commencent à faire du shopping"); }} classe statique Threadgirl étend Thread {@Override public void run () {int time = 5000; System.out.println ("La fille commence à se maquiller, le garçon attend ..."); essayez {thread.sleep (time); } catch (InterruptedException e) {e.printStackTrace (); } System.out.println ("La fille est finie avec du maquillage!, Temps pris" + temps); }}}} Le résultat de l'exécution est:
Le garçon et la fille sortent de shopping et la fille commence à se maquiller, le garçon attend. . .
Le maquillage de la fille est terminé! , 5000
Le garçon et la fille ont commencé à faire du shopping
Le garçon et la fille vont faire du shopping. La fille doit d'abord se maquiller. Une fois que la fille a terminé le maquillage, elle ira faire du shopping ensemble.
Alors, quelle est l'utilisation de JOIN (Time)?
classe publique conjointe {public static void main (String [] args) {Threadboy boy = new Threadboy (); boy.start (); } classe statique Threadboy étend Thread {@Override public void run () {System.out.println ("Boy et Girl sont prêts à faire du shopping"); Threadgirl girl = new Threadgirl (); girl.start (); INT TIME = 2000; essayez {girl.join (temps); } catch (InterruptedException e) {e.printStackTrace (); } System.out.println ("The Boy Waited" + Time + ", je ne veux plus attendre, je vais faire du shopping"); }} classe statique Threadgirl étend Thread {@Override public void run () {int time = 5000; System.out.println ("La fille a commencé à se maquiller, le garçon attendait ..."); essayez {thread.sleep (time); } catch (InterruptedException e) {e.printStackTrace (); } System.out.println ("La fille a fini de faire du temps!, Temps pris" + temps); }}} Ici, la méthode de jointure n'est remplacée que par la méthode de jointure (temps). La description a été modifiée et le résultat de l'impression est:
Le garçon et la fille sortent de shopping et la fille commence à se maquiller, le garçon attend. . .
Le garçon a attendu 2 000 et ne voulait plus attendre. Il est allé faire du shopping et la fille a fini de se maquiller! , 5000
Le garçon a attendu le temps de rejoindre (temps). Si le fil dans lequel se trouvait la fille n'a pas été exécuté après cette période, il n'attendra plus et continuera à exécuter la logique suivante, juste pour faire du shopping seul sans attendre la fille.
À partir de cela, nous pouvons voir que la méthode de jointure consiste à atteindre l'exécution synchrone de deux threads plus commodément. Le thread 1 s'exécute. Après la rencontre du thread 2, attendez l'exécution du thread 2, puis continuez d'exécuter l'exécution du thread 1. Le sens de la jointure est désormais plus visuel.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.