Java如何处理多线程中的错误？

Question

我正在开发一个多线程项目，其中Thread可能会抛出Error（而不是Exception）。没有找到任何关于多线程中如何处理错误的可靠信息，我决定做一些测试并发现结果可能不一致。

这是我的测试代码，以及评论结果。

public class MultiThreadError { 
    public static class ErrorThrowingRunnable implements Runnable{ 
     private final boolean throwsError; 
     public ErrorThrowingRunnable(boolean throwsError){ 
      this.throwsError = throwsError; 
     } 

     @Override 
     public void run() { 
      try { 
       // Wait between .5 and 1.5 seconds 
       Thread.sleep(500 + new Random().nextInt(1000)); 
      } catch (InterruptedException ex) {} 
      if(throwsError){ 
       throw new Error(Thread.currentThread().getName()); 
      }else{ 
       System.out.println(Thread.currentThread().getName()); 
      } 
     } 
    } 

    public static void regularThreadPool(){ 
     // Crashes individual thread; swallows error 
     ExecutorService threadPool = Executors.newFixedThreadPool(5); 
     threadPool.submit(new ErrorThrowingRunnable(false)); 
     threadPool.submit(new ErrorThrowingRunnable(false)); 
     threadPool.submit(new ErrorThrowingRunnable(false)); 
     threadPool.submit(new ErrorThrowingRunnable(false)); 
     threadPool.submit(new ErrorThrowingRunnable(true)); 
     threadPool.shutdown(); 
    } 

    public static void onDemandThreads(){ 
     // Crashes individual thread; displays error 
     new Thread(new ErrorThrowingRunnable(false)).start(); 
     new Thread(new ErrorThrowingRunnable(false)).start(); 
     new Thread(new ErrorThrowingRunnable(false)).start(); 
     new Thread(new ErrorThrowingRunnable(false)).start(); 
     new Thread(new ErrorThrowingRunnable(true)).start(); 
    } 

    public static void onDemandThreadPool(){ 
     // Same as onDemandThreads() 
     ExecutorService threadPool = Executors.newFixedThreadPool(5); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(true)); 
     threadPool.shutdown(); 
    } 

    public static void tooSmallThreadPool(){ 
     // When an error is thrown, apparently the thread that threw 
     // the error is not reused, reducing the pool size 
     ExecutorService threadPool = Executors.newFixedThreadPool(3); 
     threadPool.execute(new ErrorThrowingRunnable(true)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.execute(new ErrorThrowingRunnable(false)); 
     threadPool.shutdown(); 
    } 
} 

看起来好像结果应该是我的预期：抛出错误的线程终止，显示消息。事实证明，当一个Runnable传递给ExecutorService使用submit(Runnable)时，它被封装在RunnableFuture<Void>不处理错误，我找不到方法来改变这种行为，而不是直接调用execute(Runnable)，由于某种原因doesn没有表现出相同的行为。

对此有没有“最佳实践”？如果我知道一个线程可能会抛出一个错误，是否有一种方法来submit它到一个ExecutorService而不是吞下该错误？

Answer 1

是的，将您的任务提交到ExecutorService并检查返回Future的结果。

使用时：

ExecutorService es = Executors.newFixedThreadPool(1); 

Future<?> result = es.submit(new Runnable() { 
    @Override 
    public void run() { 
     throw new Error("sample error"); 
    } 
}); 

try { 
    result.get(); 
} catch (ExecutionException e) { 
    e.printStackTrace(); 
} 

您的堆栈跟踪将包含：

java.util.concurrent.ExecutionException: java.lang.Error: sample error 
    at java.util.concurrent.FutureTask.report(Unknown Source) 
    at java.util.concurrent.FutureTask.get(Unknown Source) 
    at jjj.b.B.main(B.java:23) 
Caused by: java.lang.Error: sample error 
    at jjj.b.B$1.call(B.java:18) 
    at jjj.b.B$1.call(B.java:1) 
    at java.util.concurrent.FutureTask.run(Unknown Source) 
    at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source) 
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source) 
    at java.lang.Thread.run(Unknown Source) 

Answer 2

一个Future是代表运行你的操作，无论是准备的结果，现在或在某一时刻的对象在将来。一般来说，为了得到结果，人们会调用get方法，特别是如果您将Callable而不是Runnable传入ExecutorService。

如果您的Runnable/Callable引发异常，则这将反映在Future对象中。您将可以通过调用get方法来测试Runnable是否成功运行。如果这是干净的运行，你会得到（在这种情况下）null回来。如果抛出异常，则get将抛出ExecutionException，并将该异常标记为原因。

想象它像一个音乐场地的外套检查。如果他们失去了你的外套，他们可能不会告诉你，直到你拿着你的外套要求你的外套。 Future为您的票的目的在这里。

Answer 3

试图处理从一个线程中抛出的错误似乎是一个可疑的使用情况......

从Java文档：“一个错误是Throwable的子类，表示严重的问题，合理的应用程序不应该试图大多数这样的错误都是异常情况，ThreadDeath错误虽然是一个“正常”条件，但也是Error的一个子类，因为大多数应用程序不应该试图捕获它。

我需要处理错误的唯一时间是当我使用第三方，严重管理他们的异常，抛出错误，而不是RuntimeException。在这种特定情况下，您需要捕获错误（或Throwable）以避免意外的应用程序崩溃。