Esempio di Join del Thread Java

Il metodo join di Java può essere utilizzato per mettere in pausa l’esecuzione del thread corrente fino a quando il thread specificato non è morto. Ci sono tre funzioni join sovraccaricate.

join del thread di Java

public final void join(): Questo metodo di join del thread Java mette il thread corrente in attesa fino a quando il thread su cui è chiamato non è morto. Se il thread viene interrotto, viene lanciata InterruptedException. public final synchronized void join(long millis): Questo metodo di join del thread Java viene utilizzato per attendere che il thread su cui è chiamato sia morto o attendere per un numero specificato di millisecondi. Poiché l’esecuzione del thread dipende dall’implementazione del sistema operativo, non garantisce che il thread corrente attenda solo per il tempo specificato. public final synchronized void join(long millis, int nanos): Questo metodo di join del thread Java viene utilizzato per attendere che il thread muoia per il numero specificato di millisecondi più i nanosecondi. Ecco un semplice esempio che mostra l’uso dei metodi di join del thread. L’obiettivo del programma è assicurarsi che il thread principale sia l’ultimo a terminare e il terzo thread inizi solo quando il primo è morto.

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();
        
        //avvia il secondo thread dopo aver atteso per 2 secondi o se è inattivo
        try {
            t1.join(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t2.start();
        
        //avvia il terzo thread solo quando il primo thread è inattivo
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        t3.start();
        
        //fa terminare l'esecuzione di tutti i thread prima di concludere il thread principale
        try {
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
            // TODO Blocco catch generato automaticamente
            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());
    }
    
}

L’output del programma sopra è:

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

E questo è tutto per un rapido riassunto sull’esempio di join dei thread in Java.