El método join () se usa para suspender la ejecución del subproceso que se está ejecutando actualmente hasta que el subproceso especificado esté muerto (ejecución completada). En este tutorial discutiremos el propósito y el uso del método join () con ejemplos.

¿Por qué usamos el método join ()?

En circunstancias normales, generalmente tenemos más de un subproceso, el planificador de subprocesos programa los subprocesos, lo que no garantiza el orden de ejecución del subproceso.
Por ejemplo, echemos un vistazo al siguiente código:

Sin usar join ()

Aquí tenemos tres hilos th1, th2 y th3. Aunque iniciamos los subprocesos de forma secuencial, el programador de subprocesos no los inicia y los finaliza en el orden especificado. Cada vez que ejecute este código, puede obtener un resultado diferente cada vez. Entonces, la pregunta es: ¿cómo podemos asegurarnos de que los subprocesos se ejecuten en un orden particular? La respuesta es: usar el método join () de manera apropiada.

public class JoinExample2 {
   public static void main(String[] args) {
      Thread th1 = new Thread(new MyClass2(), "th1");
      Thread th2 = new Thread(new MyClass2(), "th2");
      Thread th3 = new Thread(new MyClass2(), "th3");
         
      th1.start();
      th2.start();        
      th3.start();
   }
}
 
class MyClass2 implements Runnable{
 
    @Override
    public void run() {
    	Thread t = Thread.currentThread();
        System.out.println("Thread started: "+t.getName());
        try {
            Thread.sleep(4000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
        System.out.println("Thread ended: "+t.getName());    
    }
}

Producción:

Thread started: th1
Thread started: th3
Thread started: th2
Thread ended: th1
Thread ended: th3
Thread ended: th2

Echemos un vistazo al otro código en el que estamos usando el método join ().

El mismo ejemplo con join ()

Digamos que nuestro requisito es ejecutarlos en el orden del primero, segundo y tercero. Podemos hacer esto usando el método join () de manera apropiada.

public class JoinExample {
   public static void main(String[] args) {
      Thread th1 = new Thread(new MyClass(), "th1");
      Thread th2 = new Thread(new MyClass(), "th2");
      Thread th3 = new Thread(new MyClass(), "th3");
         
      // Start first thread immediately
      th1.start();
         
      /* Start second thread(th2) once first thread(th1) 
       * is dead
       */
      try {
          th1.join();
      } catch (InterruptedException ie) {
          ie.printStackTrace();
        }
      th2.start();
         
      /* Start third thread(th3) once second thread(th2) 
       * is dead
       */
      try {
          th2.join();
      } catch (InterruptedException ie) {
           ie.printStackTrace();
        }
      th3.start();
         
      // Displaying a message once third thread is dead
      try {
          th3.join();
      } catch (InterruptedException ie) {
            ie.printStackTrace();
        }  
      System.out.println("All three threads have finished execution");
   }
}
 
class MyClass implements Runnable{
 
    @Override
    public void run() {
    	Thread t = Thread.currentThread();
        System.out.println("Thread started: "+t.getName());
        try {
            Thread.sleep(4000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
        System.out.println("Thread ended: "+t.getName());
        
    }
}

Producción:

Thread started: th1
Thread ended: th1
Thread started: th2
Thread ended: th2
Thread started: th3
Thread ended: th3
All three threads have finished execution

En este ejemplo, hemos utilizado el método join () para que nuestros hilos se ejecuten en el orden especificado.

leer  Ciclo de vida de subprocesos en java y programación de subprocesos

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *