Wie man eine geprüfte Ausnahme von einem Java-Thread wirft?

Question

Hey, ich schreibe eine Netzwerkanwendung, in der ich Pakete mit einem benutzerdefinierten Binärformat lese. Und ich beginne einen Hintergrund-Thread, um auf eingehende Daten zu warten. Das Problem ist, dass der Compiler mich nicht erlaubt, irgendwelche Code-werfende (kontrollierte) Ausnahmen in run() zu setzen. Es heißt:

run() in (...).Listener cannot implement run() in java.lang.Runnable; overridden method does not throw java.io.IOException

Ich möchte die Ausnahme den Thread zu töten, und lassen Sie es irgendwo im übergeordneten Thread gefangen werden. Ist das möglich zu erreichen oder muss ich jede Ausnahme behandeln innerhalb der Thread?

Answer 1

Vorbehalt: Dies entspricht möglicherweise nicht Ihren Anforderungen, wenn Sie den Ausnahmemechanismus verwenden müssen.

Wenn ich Sie richtig verstehe, brauchen Sie die Ausnahme nicht wirklich zu überprüfen (Sie haben die Antwort angenommen, die eine ungeprüfte Ausnahme vorschlägt), also wäre ein einfaches Listenermuster passender?

Der Listener könnte im übergeordneten Thread leben, und wenn Sie die geprüfte Ausnahme im untergeordneten Thread abgefangen haben, können Sie den Listener einfach benachrichtigen.

Dies bedeutet, dass Sie eine Möglichkeit haben, zu enthüllen, dass dies geschieht (durch öffentliche Methoden), und mehr Informationen weitergeben können, als eine Ausnahme zulässt. Aber es bedeutet, dass es eine Kopplung (wenn auch eine lose) zwischen dem Eltern- und dem Kind-Thread geben wird. Es würde in Ihrer speziellen Situation davon abhängen, ob dies einen Vorteil gegenüber dem Umhüllen der geprüften Ausnahme mit einem unkontrollierten haben würde.

Hier ist ein einfaches Beispiel (ein Code von einer anderen Antwort geborgt):

public class ThingRunnable implements Runnable { 
    private SomeListenerType listener; 
    // assign listener somewhere 

    public void run() { 
     try { 
      while(iHaveMorePackets()) { 
       doStuffWithPacket(); 
      } 
     } catch(Exception e) { 
      listener.notifyThatDarnedExceptionHappened(...); 
     } 
    } 
} 

Die Kupplung kommt von einem Objekt in dem übergeordneten Thread des Typs sein zu müssen SomeListenerType.

Answer 2

Wenn Sie beim Auslösen der Ausnahme wirklich nichts Nützliches tun können, können Sie die geprüfte Ausnahme in eine RuntimeException umbrechen.

Answer 3

Wenn der Code Ihres Threads eine RuntimeExpection auslöst, müssen Sie keine run() - Ausnahme hinzufügen.

Aber verwenden Sie diese Lösung nur, wenn angebracht, weil dies eine schlechte pratice sein kann: http://java.sun.com/docs/books/tutorial/essential/exceptions/runtime.html

Alle Runtime oder deaktiviert Exception kann Ihnen helfen. Vielleicht müssen Sie Ihre eigene RuntimeException erstellen

Answer 4

Der Thread kann die Ausnahme nicht zu einem anderen Thread (noch zum Hauptthread) werfen. und Sie können die vererbte run() -Methode nicht dazu bringen, alle überprüften Ausnahmen auszugeben, da Sie nur weniger als den vererbten Code werfen können, nicht mehr.

Answer 5

Unter der Annahme, dass Ihr Code in einer Art Schleife ist, dann würden Sie schreiben:

public class ThingRunnable implements Runnable { 
    public void run() { 
    try { 
     while(iHaveMorePackets()) { 
     doStuffWithPacket() 
     } 
    } catch(Exception e) { 
     System.out.println("Runnable terminating with exception" + e); 
    } 
    } 
} 

Die Ausnahme, die Sie automatisch aus der Schleife brechen, und am Ende des Laufes() -Methode , der Thread wird aufhören.

Answer 6

Was ich tue, ist die Ausnahme im Thread zu fangen und speichern Sie es als eine Member-Variable der Runnable. Diese Ausnahme wird dann über einen Getter auf dem Runnable verfügbar gemacht. Ich scanne dann alle Threads vom übergeordneten Objekt, um festzustellen, ob Ausnahmen vorhanden sind, und ergreife die entsprechenden Maßnahmen.

Answer 7

Lage sein, die Ausnahme von dem übergeordneten Thread zu senden, können Sie Ihren Hintergrund-Thread in einem Callable (es erlaubt wirft auch Ausnahmen geprüft) stellen, die Sie dann auf die submit Methode der some Executor passieren. Die Methode submit gibt eine zurück, die Sie verwenden können, um die Ausnahme zu erhalten (ihre get-Methode wird eine ExecutionException werfen, die die ursprüngliche Ausnahme enthält).

Answer 8

Diese Antwort basiert auf Esko Luontola, aber es bietet ein funktionierendes Beispiel.

Im Gegensatz zur run() - Methode der Runnable-Schnittstelle erlaubt die call() - Methode von Callable das Auslösen einiger Ausnahmen. Hier ist ein Implementierungsbeispiel:

public class MyTask implements Callable<Integer> { 

    private int numerator; 
    private int denominator; 

    public MyTask(int n, int d) { 
     this.numerator = n; 
     this.denominator = d; 
    } 

    @Override 
    // The call method may throw an exception 
    public Integer call() throws Exception { 
     Thread.sleep(1000); 
     if (denominator == 0) { 
      throw new Exception("cannot devide by zero"); 
     } else { 
      return numerator/denominator; 
     } 
    } 

} 

Executor stellt einen Mechanismus ein Callable in einem Thread ausgeführt und jede Art von Ausnahmen zu behandeln:

public class Main { 

    public static void main(String[] args) { 

     // Build a task and an executor 
     MyTask task = new MyTask(2, 0); 
     ExecutorService threadExecutor = Executors.newSingleThreadExecutor(); 

     try { 
      // Start task on another thread 
      Future<Integer> futureResult = threadExecutor.submit(task); 

      // While task is running you can do asynchronous operations 
      System.out.println("Something that doesn't need the tasks result"); 

      // Now wait until the result is available 
      int result = futureResult.get(); 
      System.out.println("The result is " + result); 
     } catch (ExecutionException e) { 
      // Handle the exception thrown by the child thread 
      if (e.getMessage().contains("cannot devide by zero")) 
       System.out.println("error in child thread caused by zero division"); 
     } catch (InterruptedException e) { 
      // This exception is thrown if the child thread is interrupted. 
      e.printStackTrace(); 
     } 
    } 
} 

Answer 9

Wrapping Ihre Ausnahme innerhalb eines RuntimeException den Trick zu tun scheint .

someMethod() throws IOException 
{ 
    try 
    { 
     new Thread(() -> 
     { 
      try 
      { 
       throw new IOException("a checked exception thrown from within a running thread"); 
      } 
      catch(IOException ex) 
      { 
       throw new RuntimeException("a wrapper exception", ex); // wrap the checked exception inside an unchecked exception and throw it 
      } 
     }).start(); 
    } 
    catch(RuntimeException ex) // catch the wrapped exception sent from within the thread 
    { 
     if(ex.getCause() instanceof IOException) 
      throw ex.getCause; // unwrap the checked exception using getCause method and use it however you need 
     else 
      throw ex; 
    } 
}