Einführung in die allgemeine Methode der Ausnahmebehandlung in Java-Subthreads

Der folgende Editor bringt Ihnen einen Artikel über Ausnahmebehandlungsmethoden in Java-Subthreads (allgemein). Der Herausgeber findet es ziemlich gut, deshalb teile ich es jetzt mit Ihnen und gebe es als Referenz. Folgen wir dem Editor, um einen Blick darauf zu werfen

In einem gewöhnlichen Single-Thread-Programm sind zum Abfangen von Ausnahmen nur try...catch...finally...Codeblöcke erforderlich. Wenn also in einer gleichzeitigen Situation beispielsweise ein untergeordneter Thread im übergeordneten Thread gestartet wird, wie kann dann die Ausnahme vom untergeordneten Thread im übergeordneten Thread abgefangen und entsprechend behandelt werden?

Häufige Fehler

Manche Leute denken vielleicht, dass es sehr einfach ist, direkt dort zu versuchen, wo der übergeordnete Thread den untergeordneten Thread beginnt ... zu fangen Man macht es einfach, aber eigentlich ist das falsch.

Ursachenanalyse

Erinnern wir uns an die vollständige Signatur der run-Methode der Runnable-Schnittstelle, da die throws-Anweisung nicht identifiziert wird Die Methode löst keine aktivierte Ausnahme aus. Bei ungeprüften Ausnahmen wie RuntimeException wird der übergeordnete Thread nicht benachrichtigt, wenn eine Ausnahme auftritt, da der neue Thread von der JVM geplant und ausgeführt wird.

public abstract void run()

Lösung

Also, wie man die Daten aus dem untergeordneten Thread im erfasst Übergeordneter Thread Was ist mit Ausnahmen? Der Autor hat sich drei gängige Methoden ausgedacht und sie mit allen geteilt.

Methode 1: try...catch...

Umschließen Sie im Unterthread die Stellen, an denen Ausnahmen auftreten können, mit try ...fangen... Aussagen. Sub-Thread-Code:

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();
 }
}

Methode 2: Legen Sie den Ausnahmehandler UncaughtExceptionHandler für den Thread

Ausnahmehandler für Thread festlegen. Die spezifischen Methoden können wie folgt sein:

(1) Thread.setUncaughtExceptionHandler legt den Ausnahmehandler des aktuellen Threads fest

(2) Thread.setDefaultUncaughtExceptionHandler legt den Standard-Ausnahmehandler für das gesamte Programm fest, wenn Wenn der aktuelle Thread über einen Ausnahmehandler verfügt (Standard ist keiner), wird zuerst die Klasse UncaughtExceptionHandler verwendet. Andernfalls wird der ExceptionHandler der Threadgruppe verwendet. Der globale Standard DefaultUncaughtExceptionHandler wird verwendet; wenn keiner vorhanden ist, wird der untergeordnete Thread beendet.

Hinweis: Im untergeordneten Thread tritt eine Ausnahme auf, die die Verarbeitung übernimmt, und wird direkt beendet, ohne Protokolle zu hinterlassen. Wenn Sie also nichts unternehmen, kommt es zu einem „seltsamen“ Phänomen, bei dem die Sub-Thread-Aufgabe nicht ausgeführt wird und keine Protokollaufforderung erfolgt.

Legen Sie den Ausnahmehandler für den aktuellen Thread fest:

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));
  }
 }
}

Oder legen Sie den Standard-Ausnahmehandler für alle Threads fest

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));
  }
 }
}

Befehlszeilenausgabe: Tun Sie etwas 1

Ausnahme im untergeordneten Thread behandeln.

Methode Drittens: Fangen Sie die Ausnahme über die get-Methode von Future ab.

Verwenden Sie den Thread-Pool, um eine Methode zu senden, die die Rückgabeinformationen abrufen kann, d. h. ExecutorService.submit(Callable) kann sie abrufen Ein Thread zur Ausführung nach dem Senden des resultierenden Future-Objekts. Wenn im untergeordneten Thread eine Ausnahme auftritt, kann beim Abrufen des Rückgabewerts über Future.get () die ExecutionException-Ausnahme abgefangen werden, wodurch bekannt ist, dass im untergeordneten Thread eine Ausnahme aufgetreten ist untergeordneter Thread.

Code des untergeordneten Threads:

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 des übergeordneten Threads:

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();
   }
  }
 }
}

Befehlszeilenausgabe: Etwas tun 1

Ausnahme im untergeordneten Thread behandeln java.lang.RuntimeException: ChildThread1-Ausnahme

Zusammenfassung

Die oben genannten sind drei häufig verwendete Methoden zur Ausnahmebehandlung von Java-Sub-Threads. Tatsächlich hat sich der Autor auch mehrere andere Lösungen für bestimmte Szenarien ausgedacht. Ich werde sie an einem anderen Tag analysieren. Vielen Dank für Ihre Unterstützung

Das obige ist der detaillierte Inhalt vonEinführung in die allgemeine Methode der Ausnahmebehandlung in Java-Subthreads. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!