Introduction à la méthode générale de gestion des exceptions dans les sous-threads Java

L'éditeur suivant vous proposera un article basé sur les méthodes de gestion des exceptions dans les sous-threads Java (général). L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur pour y jeter un œil

Dans un programme monothread ordinaire, la détection des exceptions ne nécessite que des blocs de code try...catch...finally.... Ainsi, dans une situation concurrente, par exemple, si un thread enfant est démarré dans le thread parent, comment intercepter l'exception du thread enfant dans le thread parent et la gérer en conséquence ?

Erreurs courantes

Certaines personnes peuvent penser que c'est très simple, essayez directement là où le fil parent commence le fil enfant... catch 1 Faites-le, mais en réalité, c'est faux.

Analyse des causes

Rappelons la signature complète de la méthode run de l'interface Runnable. L'instruction throws n'étant pas identifiée, la La méthode ne lancera pas d'exception vérifiée. Quant aux exceptions non vérifiées telles que RuntimeException, puisque le nouveau thread est planifié et exécuté par la JVM, si une exception se produit, le thread parent ne sera pas averti.

public abstract void run()

Solution

Alors, comment capturer les données du fil de discussion enfant dans le fil de discussion parent Qu'en est-il des exceptions ? L'auteur a pensé à 3 méthodes courantes et les a partagées avec tout le monde.

Méthode 1 : try...catch...

Dans le sous-thread, enveloppez les endroits où des exceptions peuvent se produire avec try ...attraper... les déclarations. Code du sous-thread :

public class ChildThread implements Runnable {
 public void run() {
  doSomething1();
  try {
   // 可能发生异常的方法
   exceptionMethod();
  } catch (Exception e) {
   // 处理异常
   System.out.println(String.format("handle exception in child thread. %s", e));
  }
  doSomething2();
 }
}

Méthode 2 : définir le gestionnaire d'exceptions UncaughtExceptionHandler pour le thread

Définir le gestionnaire d'exceptions pour le thread. Les méthodes spécifiques peuvent être les suivantes :

(1) Thread.setUncaughtExceptionHandler définit le gestionnaire d'exceptions du thread actuel

(2) Thread.setDefaultUncaughtExceptionHandler définit le gestionnaire d'exceptions par défaut pour l'ensemble du programme si le courant Si le thread a un gestionnaire d'exceptions (la valeur par défaut est aucun), la classe UncaughtExceptionHandler sera utilisée en premier ; sinon, si le groupe de threads auquel appartient le thread actuel a un gestionnaire d'exceptions, le ExceptionHandler du groupe de threads sera utilisé autrement ; le défaut global DefaultUncaughtExceptionHandler sera utilisé ; s’il n’y en a pas, le thread enfant se fermera.

Remarque : Si une exception se produit dans le thread enfant, s'il n'y a pas de classe pour prendre en charge le traitement, il se terminera directement sans laisser de logs. Par conséquent, si vous ne faites rien, il y aura un phénomène « étrange » dans lequel la tâche de sous-thread ne sera pas exécutée et il n'y aura pas d'invite de journalisation.

Définissez le gestionnaire d'exceptions pour le thread actuel :

public class ChildThread implements Runnable { 
 private static ChildThreadExceptionHandler exceptionHandler;

 static {
  exceptionHandler = new ChildThreadExceptionHandler();
 }

 public void run() {
  Thread.currentThread().setUncaughtExceptionHandler(exceptionHandler);
  System.out.println("do something 1");
  exceptionMethod();
  System.out.println("do something 2");
 }

 public static class ChildThreadExceptionHandler implements Thread.UncaughtExceptionHandler {
  public void uncaughtException(Thread t, Throwable e) {
   System.out.println(String.format("handle exception in child thread. %s", e));
  }
 }
}

Ou définissez le gestionnaire d'exceptions par défaut pour tous les threads

public class ChildThread implements Runnable {
 private static ChildThreadExceptionHandler exceptionHandler;

 static {
  exceptionHandler = new ChildThreadExceptionHandler();
  Thread.setDefaultUncaughtExceptionHandler(exceptionHandler);
 }

 public void run() {
  System.out.println("do something 1");
  exceptionMethod();
  System.out.println("do something 2");
 }

 private void exceptionMethod() {
  throw new RuntimeException("ChildThread exception");
 }

 public static class ChildThreadExceptionHandler implements Thread.UncaughtExceptionHandler {
  public void uncaughtException(Thread t, Throwable e) {
   System.out.println(String.format("handle exception in child thread. %s", e));
  }
 }
}

Sortie de la ligne de commande : faites quelque chose 1

gérer l'exception dans le thread enfant java.lang.RuntimeException : exception ChildThread

méthode Troisièmement, interceptez les exceptions via la méthode get de Future

Utilisez le pool de threads pour soumettre une méthode qui peut obtenir les informations de retour, c'est-à-dire qu'ExecutorService.submit(Callable) peut obtenir un thread pour l'exécution après la soumission. L'objet Future résultant, et si une exception se produit dans le thread enfant, lors de l'obtention de la valeur de retour via future.get(), l'exception ExecutionException peut être interceptée, sachant ainsi qu'une exception s'est produite dans l'enfant. fil de discussion.

Code du fil de discussion enfant :

public class ChildThread implements Callable {
 public Object call() throws Exception {
  System.out.println("do something 1");
  exceptionMethod();
  System.out.println("do something 2");
  return null;
 }

 private void exceptionMethod() {
  throw new RuntimeException("ChildThread1 exception");
 }
}

Code du fil de discussion parent :

public class Main {
 public static void main(String[] args) {
  ExecutorService executorService = Executors.newFixedThreadPool(8);
  Future future = executorService.submit(new ChildThread());
  try {
   future.get();
  } catch (InterruptedException e) {
   System.out.println(String.format("handle exception in child thread. %s", e));
  } catch (ExecutionException e) {
   System.out.println(String.format("handle exception in child thread. %s", e));
  } finally {
   if (executorService != null) {
    executorService.shutdown();
   }
  }
 }
}

Sortie de la ligne de commande : faites quelque chose 1

gérer l'exception dans le thread enfant java.util.concurrent.ExecutionException : java.lang.RuntimeException : exception ChildThread1

Résumé

Ci-dessus sont 3 méthodes de gestion des exceptions de sous-thread Java couramment utilisées. En fait, l'auteur a également pensé à plusieurs autres solutions dans des scénarios spécifiques, je les analyserai un autre jour. Merci pour votre soutien~

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!