Java Thread Join Beispiel

Die Methode Java Thread join kann verwendet werden, um die Ausführung des aktuellen Threads anzuhalten, bis der angegebene Thread tot ist. Es gibt drei überladene Join-Funktionen.

Java Thread join

public final void join(): Diese Java-Thread-Join-Methode setzt den aktuellen Thread in den Wartezustand, bis der Thread, auf dem sie aufgerufen wird, tot ist. Wenn der Thread unterbrochen wird, wirft er InterruptedException. public final synchronized void join(long millis): Diese Java-Thread-Join-Methode wird verwendet, um auf den Thread zu warten, auf dem sie aufgerufen wird, bis er tot ist oder bis die angegebene Anzahl von Millisekunden verstrichen ist. Da die Thread-Ausführung von der Betriebssystemimplementierung abhängt, wird nicht garantiert, dass der aktuelle Thread nur die angegebene Zeit wartet. public final synchronized void join(long millis, int nanos): Diese Java-Thread-Join-Methode wird verwendet, um auf den Thread zu warten, bis die angegebene Anzahl von Millisekunden plus Nanosekunden verstrichen ist. Hier ist ein einfaches Beispiel zur Verwendung der Thread join-Methoden. Das Ziel des Programms ist es sicherzustellen, dass main der letzte Thread ist, der beendet wird, und der dritte Thread erst gestartet wird, wenn der erste tot ist.

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();
        
        //starte den zweiten Thread nach einer Wartezeit von 2 Sekunden oder wenn er beendet ist
        try {
            t1.join(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t2.start();
        
        //starte den dritten Thread nur, wenn der erste Thread beendet ist
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t3.start();
        
        //lass alle Threads ihre Ausführung beenden, bevor der Hauptthread beendet wird
        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            //TODO Auto-generierter Catch-Block
            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());
    }
    
}

Die Ausgabe des obigen Programms ist:

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

Das ist alles für eine kurze Zusammenfassung des Java-Thread-Join-Beispiels.