Voorbeeld van het samenvoegen van Java-draad

Java Thread join methode kan worden gebruikt om de uitvoering van de huidige thread te onderbreken totdat de gespecificeerde thread dood is. Er zijn drie overbelaste join-functies.

Java Thread join

public final void join(): Deze java thread join-methode plaatst de huidige thread in de wachtstand totdat de thread waarop het wordt aangeroepen, dood is. Als de thread wordt onderbroken, wordt InterruptedException gegenereerd. public final synchronized void join(long millis): Deze java thread join-methode wordt gebruikt om te wachten tot de thread waarop het wordt aangeroepen, dood is, of wacht voor het opgegeven aantal milliseconden. Aangezien de uitvoering van de thread afhankelijk is van de implementatie van het besturingssysteem, garandeert het niet dat de huidige thread alleen wacht voor de opgegeven tijd. public final synchronized void join(long millis, int nanos): Deze java thread join-methode wordt gebruikt om te wachten tot de thread sterft gedurende de opgegeven milliseconden plus nanoseconden. Hier is een eenvoudig voorbeeld dat het gebruik van Thread join-methoden laat zien. Het doel van het programma is ervoor te zorgen dat ‘main’ de laatste thread is die eindigt en dat de derde thread pas begint wanneer de eerste dood is.

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();
        
        //start tweede thread na het wachten van 2 seconden of als het dood is
        try {
            t1.join(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t2.start();
        
        //start derde thread alleen wanneer de eerste thread dood is
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t3.start();
        
        //laat alle threads hun uitvoering voltooien voordat de hoofdthread eindigt
        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            // TODO Automatisch gegenereerde catch-blok
            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());
    }
    
}

De uitvoer van het bovenstaande programma is:

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

Dat is alles voor een snelle samenvatting van het java thread join voorbeeld.