Wie gehe ich mit nicht abgefangenen Ausnahmen um, die von Threads in Java ausgelöst werden?

Von Threads ausgelöste Ausnahmen abfangen

Wenn in Java ein neuer Thread erstellt wird, führt er seine run()-Methode gleichzeitig mit der Hauptmethode aus Faden. Allerdings können Ausnahmen, die innerhalb eines Threads ausgelöst werden, nicht direkt in der Hauptklasse behandelt werden.

Betrachten Sie den folgenden Code:

public class Test extends Thread {
  public static void main(String[] args) throws InterruptedException {
    Test t = new Test();

    try {
      t.start();
      t.join();
    } catch(RuntimeException e) {
      System.out.println("** RuntimeException from main");
    }

    System.out.println("Main stopped");
  }

  @Override
  public void run() {
    try {
      while(true) {
        System.out.println("** Started");

        sleep(2000);

        throw new RuntimeException("exception from thread");
      }
    } catch (RuntimeException e) {
      System.out.println("** RuntimeException from thread");

      throw e;
    } catch (InterruptedException e) {

    }
  }
}

In diesem Code wird eine Laufzeitausnahme vom Thread ausgelöst, aber es wird nicht in der Hauptklasse gefangen. Um dieses Problem zu beheben, bietet Java einen praktischen Mechanismus namens Thread.UncaughtExceptionHandler.

Verwendung von Thread.UncaughtExceptionHandler

Ein Thread.UncaughtExceptionHandler bietet eine Möglichkeit, Ausnahmen zu behandeln nicht in einem Thread gefangen. Um es zu verwenden, weisen Sie dem Thread mit setUncaughtExceptionHandler() einen Handler zu und überschreiben Sie dessen uncaughtException()-Methode, um die Ausnahmebehandlungslogik zu definieren.

Hier ist ein Beispiel:

Thread.UncaughtExceptionHandler h = new Thread.UncaughtExceptionHandler() {
    @Override
    public void uncaughtException(Thread th, Throwable ex) {
        System.out.println("Uncaught exception: " + ex);
    }
};
Thread t = new Thread() {
    @Override
    public void run() {
        System.out.println("Sleeping ...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println("Interrupted.");
        }
        System.out.println("Throwing exception ...");
        throw new RuntimeException();
    }
};
t.setUncaughtExceptionHandler(h);
t.start();

Hier Code gibt der Handler die nicht abgefangene Ausnahme an die Konsole aus. Durch die Verwendung des Thread.UncaughtExceptionHandler können innerhalb eines Threads ausgelöste Ausnahmen effektiv in der Hauptklasse behandelt werden.

Das obige ist der detaillierte Inhalt vonWie gehe ich mit nicht abgefangenen Ausnahmen um, die von Threads in Java ausgelöst werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!