Programa Java para usar excepciones con subprocesos

Se exceptúan los eventos que ocurren debido al error del programador o error de la máquina que provoca una perturbación en el flujo normal de ejecución del programa. Cuando un método encuentra una condición anormal que no puede manejar, se lanza una excepción como declaración de excepción. Las excepciones son capturadas por los controladores (aquí el bloque catch). Las excepciones son detectadas por los controladores colocados junto con la pila de invocación del método del subproceso. Si el método de llamada no está preparado para capturar la excepción, lanza la excepción a su método de llamada y así sucesivamente. Entonces, en el programa Java, los controladores de excepciones deben colocarse estratégicamente, de modo que el programa atrape todas las excepciones de las que el programa desea recuperarse.

Ciclo de vida de un subproceso : la clase implementa una clase de subproceso o una interfaz ejecutable, luego la clase extendida tiene el método start() para ejecutar el subproceso, los métodos sleep() hacen que el subproceso que se está ejecutando actualmente entre en suspensión durante el número especificado de milisegundos , y muchos más.                         

Antes de discutir los enfoques, indique. Se deben conocer las transacciones de subprocesos para tratar más a fondo las excepciones para una mejor comprensión. Un subproceso en Java en cualquier momento existe en cualquiera de los siguientes estados. Un hilo se encuentra solo en uno de los estados mostrados en cualquier instante:

1. Nuevo
2. Ejecutable
3. Obstruido
4. Esperando
5. Espera cronometrada
6. Terminado

1. Un nombre de clase RunnableThread  implementa la interfaz Runnable que proporciona el método run( ) ejecutado por el hilo. El objeto de esta clase ahora es ejecutable

2. El constructor Thread se utiliza para crear un objeto de la clase RunnableThread pasando el objeto ejecutable como parámetro.

3. El método start() se invoca en el objeto Thread ya que regresa inmediatamente una vez que se ha generado un hilo.

4. El subproceso finaliza cuando finaliza el método run(), que será una terminación normal o una excepción detectada.

5. Ahora para crear un nuevo hilo

runner = new Thread(this,threadName) ;

6. Para comenzar el nuevo hilo.

runner. start() ;

7 . public void run( ) es un método anulable que se usa para mostrar la información de un subproceso en particular.

8. Thread.currentThread().sleep(2000) se usa para desactivar el subproceso hasta que el siguiente subproceso comience a ejecutarse o se usa para retrasar el subproceso actual.

El controlador de excepciones no detectado se usará para demostrar el uso de la excepción con el subproceso. Es una interfaz específica proporcionada por Java para manejar la excepción en el método de ejecución del subproceso.

Hay dos métodos para crear un hilo: 

1. Extienda la clase de hilo (java.lang.thread)
2. Implementar interfaz ejecutable ( java.lang.thread)

1. Excepciones y manejo de excepciones con subprocesos

Aquí, se crea un nuevo subproceso en la clase que amplía la clase de subproceso en la que se anula el método run() . Esto invoca el punto de entrada del nuevo hilo creado en la clase que estaba extendiendo la clase de hilo. Además, el método start() se usa para iniciar y ejecutar el hilo en el programa. 

// Java program to Use exceptions with thread
  
// Importing Classes/Files
import java.io.*;
  
// Child Class(Thread) is inherited from parent Class(GFG)
class GFG extends Thread {
  
    // Function to check if thread is running
    public void run()
    {
        System.out.println("Thread is running");
  
        // Using for loop to iterate
        for (int i = 0; i < 10; ++i) {
            System.out.println("Thread loop running " + i);
        }
    }
  
    // Main Driver Method
    public static void main(String[] args)
    {
  
        // Try-catch block to detect exception
        try {
  
            // Creating new thread
            GFG ob = new GFG();
  
            throw new RuntimeException();
        }
  
        // Catch block to handle exception
        catch (Exception e) {
  
            // Exception handler
            System.out.println(
                "Another thread is not supported");
        }
    }
}

Producción:

Another thread is not supported

2. Manejo de excepciones con el método de suspensión(): el método de suspensión() de la clase de subproceso se usa cuando existe una demanda para suspender el subproceso durante un período de tiempo particular para el flujo de trabajo adecuado del código.

Sintaxis:

sueño de vacío estático público (milisegundos largos); // generalmente usado

sueño de vacío estático público (milisegundos largos, nanosegundos int); // usado para ilustrar la precisión solamente 

Parámetro: 

Tipo de retorno: Como se ve en la propia sintaxis, no devuelve ningún valor.

Excepción: a menudo arroja excepciones, ya que el lenguaje java involucra el concepto de subprocesamiento múltiple

1. IllegalArgumentException se lanza cuando el valor paramétrico es negativo, ya que está limitado como se discutió entre [0 — +999999]
2. InterrupteException se lanza cuando un subproceso se interrumpe con un subproceso en curso, como se explicó, java admite los conceptos de subprocesamiento múltiple.

Implementación:

// Java program to Use exceptions with thread
  
/* Note: Dont confuse main method with Main class*/
  
// Importing Classes/Files
import java.io.*;
  
// Child Class(Thread) is inherited
// from parent Class(GFG)
class GFG extends Thread {
    public void run()
    {
        System.out.println("Throwing in "
                           + "MyThread");
        throw new RuntimeException();
    }
}
  
// Main driver method
public class Main {
    public static void main(String[] args)
    {
        GFG t = new GFG();
        t.start();
  
        // try block to deal with exception
        try {
            Thread.sleep(2000);
        }
  
        // catch block to handle the exception
        catch (Exception x) {
            // Print command when exception encountered
            System.out.println("Exception" + x);
        }
  
        // Print command just to show program
        // run successfully
        System.out.println("Completed");
    }
}

Producción:

Throwing in MyThread
Exception in thread "Thread-0" java.lang.RuntimeException
        at testapp.MyThread.run(Main.java:19)
Completed