Exemple de jointure de thread Java

La méthode join de Thread Java peut être utilisée pour mettre en pause l’exécution du thread actuel jusqu’à ce que le thread spécifié soit terminé. Il existe trois fonctions de join surchargées.

join de Thread Java

public final void join() : Cette méthode join de thread Java met le thread actuel en attente jusqu’à ce que le thread sur lequel elle est appelée soit terminé. Si le thread est interrompu, il lance InterruptedException. public final synchronized void join(long millis) : Cette méthode join de thread Java est utilisée pour attendre que le thread sur lequel elle est appelée soit terminé ou attendre pendant les millisecondes spécifiées. Comme l’exécution du thread dépend de l’implémentation du système d’exploitation, cela ne garantit pas que le thread actuel attendra seulement pendant le temps donné. public final synchronized void join(long millis, int nanos) : Cette méthode join de thread Java est utilisée pour attendre que le thread se termine pendant les millisecondes spécifiées plus les nanosecondes. Voici un exemple simple montrant l’utilisation des méthodes join de Thread. L’objectif du programme est de s’assurer que main est le dernier thread à terminer et que le troisième thread ne démarre que lorsque le premier est terminé.

package com.journaldev.threads;

public class ThreadJoinExample {

    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable(), "t1");
        Thread t2 = new Thread(new MyRunnable(), "t2");
        Thread t3 = new Thread(new MyRunnable(), "t3");
        
        t1.start();
        
        //démarrer le deuxième thread après avoir attendu 2 secondes ou s'il est inactif
        try {
            t1.join(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t2.start();
        
        //démarrer le troisième thread uniquement lorsque le premier thread est inactif
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t3.start();
        
        //laisser tous les threads terminer l'exécution avant de terminer le thread principal
        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            // TODO Bloc d'attrapage généré automatiquement
            e.printStackTrace();
        }
        
        System.out.println("All threads are dead, exiting main thread");
    }

}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("Thread started:::"+Thread.currentThread().getName());
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread ended:::"+Thread.currentThread().getName());
    }
    
}

La sortie du programme ci-dessus est:

Thread started:::t1
Thread started:::t2
Thread ended:::t1
Thread started:::t3
Thread ended:::t2
Thread ended:::t3
All threads are dead, exiting main thread

C’est tout pour un tour d’horizon rapide sur l’exemple de jointure de thread en Java.