Manejador de excepciones no detectadas
El método de ejecución del subproceso no puede arrojar ninguna excepción marcada, pero las excepciones no verificadas pueden hacer que el subproceso termine. En este caso, el subproceso morirá, lo que también hará que el subproceso principal termine de manera anormal.。
Para las excepciones que se pueden propagar, la excepción se pasa a un controlador para las excepciones no detectadas antes de que el hilo muera. La premisa es que el procesador debe ser una clase que implemente Thread.UncaughtExceptionHandlerla interfaz。
¿Qué significan estas palabras?, sigue leyendo.
De la siguiente manera, si lanzo una excepción a la fuerza en el método de ejecución, se informará un error.
Entonces, cuando se encuentra una excepción en el hilo, try-catchsolo podemos capturar la excepción tanto como sea posible.
Pero en el método de ejecución de cada subproceso, es imposible para nosotros envolver cada oración de código en un try-catchbloque de código grande. Las excepciones marcadas deben envolverse con bloques de código try-catch, pero también hay muchas excepciones no verificadastry-catch . No podemos garantizar que las excepciones no verificadas no salgan mal, pero no es apropiado envolver todas las excepciones no verificadas .
Por favor, vea el código a continuación.
La primera pieza de código:
package concurrence;
public class UncaughtExceptionHandlerTest {
public static void main(String[] args) throws InterruptedException {
try {
Thread thread1 = new Thread(new MyRunnable());
thread1.start();
} catch (Exception ex) {
System.out.println("Exception:" + ex.getMessage());
}
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(2 / 1);
System.out.println(2 / 0);
System.out.println(2 / 2);
}
}
En el método de ejecución del subproceso 1, hay un 2/0error, que es ArithmeticExceptionuna excepción. Esta es una excepción no verificada, por lo que no try-catchla envolvimos con un bloque de código. Pero una vez que el código arroja una excepción no verificada , no podemos detectarla en otros subprocesos. Por lo tanto, aunque traté de detectar excepciones no verificadas en el subproceso principal , no pude detectarlas y, finalmente, el programa tuvo que terminar debido a las excepciones.
Normalmente, consulte:
La segunda pieza de código:
package concurrence;
public class Test {
public static void main(String[] args) {
try {
dividByZero();
} catch (Exception ex) {
System.out.println("Exception:" + ex);
}
}
public static void dividByZero() {
System.out.println(2 / 1);
System.out.println(2 / 0);
System.out.println(2 / 2);
}
}
En circunstancias normales, podemos capturar excepciones no verificadas para que nuestro programa no finalice debido a excepciones.
Pero ahora, en subprocesos múltiples, no podemos detectar una excepción no verificada en el método de ejecución . ¿Significa esto que si no detectamos la excepción no verificada con un bloque de código runen el método , el programa terminará debido a la excepción?try- catch
Por supuesto que no, en este momento puedes debutar UncaughtExceptionHandler.
Para las excepciones que se pueden propagar, la excepción se pasa a un controlador para las excepciones no detectadas antes de que el hilo muera. La premisa es que el procesador debe ser una clase que implemente Thread.UncaughtExceptionHandlerla interfaz.
Entonces, MyUncaughtExceptionHandlerreescribí el método en la clase Thread.UncaughtExceptionHandlery uncaughtExceptiondefiní el manejo de excepciones en este método. Luego thread1 start, antes, use setUncaughtExceptionHandlerel método para establecer el hilo.
La tercera pieza de código:
package concurrence;
public class UncaughtExceptionHandlerTest {
public static void main(String[] args) throws InterruptedException {
try {
Thread thread1 = new Thread(new MyRunnable());
thread1.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
thread1.start();
} catch (Exception ex) {
System.out.println("Exception:" + ex.getMessage());
}
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(2 / 1);
System.out.println(2 / 0);
System.out.println(2 / 2);
}
}
class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println(t.getName() + " " + e.getMessage());
}
}
De esta manera, cuando ocurre una excepción no verificada en el método de ejecución , antes de la muerte del subproceso 1, podemos capturar la excepción en el subproceso principal, de modo que el programa principal también pueda finalizar normalmente y no se terminará debido a la excepción. .
Reimpreso: https://blog.csdn.net/qq_42799615/article/details/111658473