如何從java線程拋出一個檢查異常？

Question

嘿，我正在寫一個網絡應用程序，我在其中讀取一些自定義二進制格式的數據包。我開始一個後臺線程來等待傳入的數據。問題是，編譯器不讓我把任何代碼拋出（檢查）異常到run()。它說：

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

我想要異常殺死線程，並讓它在父線程中的某處被捕獲。這是可能實現或我必須處理線程中的每個異常？

Answer 1

警告：如果您必須使用異常機制，則可能無法滿足您的需求。

如果我正確理解你，你實際上並不需要檢查異常（你已經接受了提示未檢查異常的答案），那麼簡單的監聽模式會更合適嗎？

監聽器可以住在父線程，而當你已經陷入子線程的檢查異常，你可以簡單地通知聽衆。

這意味着你有暴露，這將發生（通過public方法）的一種方式，並能夠傳遞更多信息不是例外允許。但它確實意味着在父線程和子線程之間會有一個耦合（雖然是一個鬆散的）。這將取決於您的具體情況，這是否會比用未選中的方式包裝檢查的異常有好處。

下面是一個簡單的例子（一些代碼從另一個答案借）：

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

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

耦合來自一個物體在具有成爲SomeListenerType類型的父線程。

Answer 2

如果在引發異常時確實無法做任何有用的事情，可以將檢查的異常包裝在RuntimeException中。

try { 
    // stuff 
} catch (CheckedException yourCheckedException) { 
    throw new RuntimeException("Something to explain what is happening", yourCheckedException); 
} 

Answer 3

如果您的線程代碼拋出RuntimeExpection，則不需要添加run（）throw Exception。

但使用此解決方案只有在適當的時候，因爲這可能是一個壞的初步實踐： http://java.sun.com/docs/books/tutorial/essential/exceptions/runtime.html

任何RuntimeException的或未經檢查的異常可以幫助你。也許你需要創建自己的RuntimeException

Answer 4

線程不能將異常拋出到任何其他線程（或主線程）。你不能讓繼承的run（）方法拋出任何檢查的異常，因爲你只能拋出少於繼承的代碼，而不是更多。

Answer 5

在你的代碼是在某種循環的假設，你會寫：

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

異常將自動中斷你出你的循環，並在運行結束（）方法，線程將停止。

Answer 6

我所做的是在線程中捕獲異常並將其存儲爲Runnable的成員變量。這個異常然後通過Runnable上的getter公開。然後，我掃描父級的所有線程，看看是否有異常，並採取適當的措施。

Answer 7

爲了能夠將異常發送到父線程，可以將您的後臺線程放在Callable（它允許拋出異常），然後將其傳遞給some Executor的submit方法。提交方法將返回一個Future，然後您可以使用該方法來獲取該異常（其get方法將拋出包含原始異常的ExecutionException）。

Answer 8

此答案基於Esko Luontola，但它提供了一個工作示例。

與Runnable接口的run（）方法不同，Callable的call（）方法允許拋出一些異常。下面是一個實現的例子：

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

} 

執行人提供了一種機制，以一個線程中運行一個可調用和處理任何類型的異常：

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

包裝一下你的例外內RuntimeException似乎做的伎倆。

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