我试图使用Java的ThreadPoolExecutor类运行大量具有固定数量线程的重量级任务。每个任务都有许多可能由于异常而失败的地方。
我已经继承了ThreadPoolExecutor的子类，并且重写了afterExecute方法，该方法应该提供在运行任务时遇到的任何未捕获的异常。然而，我似乎不能让它工作。
例如:
public class ThreadPoolErrors extends ThreadPoolExecutor {
public ThreadPoolErrors() {
super( 1, // core threads
1, // max threads
1, // timeout
TimeUnit.MINUTES, // timeout units
new LinkedBlockingQueue<Runnable>() // work queue
);
}
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if(t != null) {
System.out.println("Got an error: " + t);
} else {
System.out.println("Everything's fine--situation normal!");
}
}
public static void main( String [] args) {
ThreadPoolErrors threadPool = new ThreadPoolErrors();
threadPool.submit(
new Runnable() {
public void run() {
throw new RuntimeException("Ouch! Got an error.");
}
}
);
threadPool.shutdown();
}
}
这个程序的输出是“一切正常——情况正常!”，尽管提交给线程池的唯一Runnable抛出了异常。你知道这里发生了什么吗?
谢谢!
警告:需要注意的是，此解决方案将阻塞将来的调用线程。get()。
如果您想处理任务抛出的异常，那么通常使用Callable而不是Runnable更好。
Callable.call()允许抛出检查过的异常，这些异常会传播回调用线程:
Callable task = ...
Future future = executor.submit(task);
// do something else in the meantime, and then...
try {
future.get();
} catch (ExecutionException ex) {
ex.getCause().printStackTrace();
}
如果Callable.call()抛出异常，则该异常将被包装在ExecutionException中并由Future.get()抛出。
这可能比继承ThreadPoolExecutor的子类要好得多。如果异常是可恢复的，它还为您提供了重新提交任务的机会。
警告:需要注意的是，此解决方案将阻塞将来的调用线程。get()。
如果您想处理任务抛出的异常，那么通常使用Callable而不是Runnable更好。
Callable.call()允许抛出检查过的异常，这些异常会传播回调用线程:
Callable task = ...
Future future = executor.submit(task);
// do something else in the meantime, and then...
try {
future.get();
} catch (ExecutionException ex) {
ex.getCause().printStackTrace();
}
如果Callable.call()抛出异常，则该异常将被包装在ExecutionException中并由Future.get()抛出。
这可能比继承ThreadPoolExecutor的子类要好得多。如果异常是可恢复的，它还为您提供了重新提交任务的机会。
从文档中可以看出:
注意:当动作被包含在
task(例如FutureTask)
显式地或通过方法
提交时，这些任务对象会捕获和
维护计算性异常和
所以它们不会引起突然性
终止，和内部
异常不会传递给this
方法。
当你提交一个Runnable时，它会被包装在一个Future中。
你的afterExecute应该是这样的:
public final class ExtendedExecutor extends ThreadPoolExecutor {
// ...
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t == null && r instanceof Future<?>) {
try {
Future<?> future = (Future<?>) r;
if (future.isDone()) {
future.get();
}
} catch (CancellationException ce) {
t = ce;
} catch (ExecutionException ee) {
t = ee.getCause();
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
}
}
if (t != null) {
System.out.println(t);
}
}
}
医生的例子并没有给我想要的结果。
当线程进程被放弃(带有显式的interput();s)时，出现异常。
我也想保留这个“系统”。exit”的功能，一个正常的主线程有一个典型的抛出，我想这样程序员就不会被迫在代码上工作，而不得不担心它的上下文(…一个线程)，如果出现任何错误，它必须是一个编程错误，或者这种情况必须解决的地方，手动捕获…没有必要过于复杂。
所以我修改了代码来满足我的需要。
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t == null && r instanceof Future<?>) {
Future<?> future = (Future<?>) r;
boolean terminate = false;
try {
future.get();
} catch (ExecutionException e) {
terminate = true;
e.printStackTrace();
} catch (InterruptedException | CancellationException ie) {// ignore/reset
Thread.currentThread().interrupt();
} finally {
if (terminate) System.exit(0);
}
}
}
但是要小心，这段代码基本上将你的线程转换为主线程异常，同时保持所有的并行属性…但是让我们面对现实，在系统的并行机制(扩展Thread)的功能上设计架构是错误的方法……除非严格要求使用事件驱动设计....但后来…如果这是需求，那么问题是:在这种情况下是否需要ExecutorService ?……也许不是。
