如果发生异常，则退出Java Callable

我使用的是ExecutorService和Java中的Callable。实现Callable的类在文件系统上执行一些IO工作。如果发生异常，如何停止可调用的执行并从中退出

这是一个实现Callable的示例类，它有两个方法：foo1（）和foo2（）

公共类MyCallable实现可调用{
公共对象调用（）引发IOException、SQLException{
//方法1可能引发IOException
foo1（）；
//方法2可能引发SQLException
foo2（）；
返回null；
}
}

这是示例执行服务类。它可以通过futures对象处理并行处理过程中发生的异常

public class MyExecutorService {
    ExecutorService listProcessor;
    listProcessor = Executors.newFixedThreadPool(2);
    List<Callable<Object>> callableTodo = new ArrayList<Callable<Object>>();

    // add the callables to the todo list
    callableTodo.add(new MyCallable<Object>());
    callableTodo.add(new MyCallable<Object>());

    // start the threads
    List<Future<Object>> futures = listProcessor.invokeAll(callableTodo);
    listProcessor.shutdown();
    listProcessor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);

    // futures now holds possible exceptions
    for (Future<Object> future : futures) {
     try {
        future.get();
     } catch (ExecutionException e) {
         // process the exception
     }
    }
}

公共类MyExecutorService{
执行器服务列表处理器；
listProcessor=Executors.newFixedThreadPool（2）；
List callableTodo=new ArrayList（）；
//将可调用项添加到待办事项列表中
add（newmycallable（））；
add（newmycallable（））；
//启动线程
List futures=listProcessor.invokeAll（callableTodo）；
listProcessor.shutdown（）；
listProcessor.WaitTermination（Long.MAX_值，时间单位纳秒）；
//期货现在有可能例外
for（未来：未来）{
试一试{
future.get（）；
}捕获（执行例外）{
//处理异常
}
}
}

但我想在foo1（）中发生IOException时立即停止MyCallable，而不是在foo2（）中继续

---

编辑：此外，如果在foo1（）中发生未经检查的异常（如RuntimeException），MyCallable也需要停止

可调用的

方法的签名是

V call（）引发异常

它的描述是

计算结果，如果无法执行此操作，则引发异常

换句话说，就是不要捕获
IOException
。如果您没有捕获到它，那么执行将停止，异常将被传递到一个级别

注意：如果方法被标记为引发异常类型，则这仅适用于非运行时异常，而
调用
被标记为do，因为它被声明为
引发异常

正如您已经知道的，
Future
的
.get
方法将在可调用的
抛出异常时抛出异常。
这就是将发生的情况。如果foo1抛出异常，call（）方法将立即停止执行。是什么让您认为它不会停止？从我最初的问题来看，这并不明显，但运行时异常是否也会冒泡并迫使可调用程序停止？是的，当然。还有什么事情会发生？在使用并发之前，您应该真正了解异常的基本知识，这是一个非常非常复杂的问题。
public class MyExecutorService {
    ExecutorService listProcessor;
    listProcessor = Executors.newFixedThreadPool(2);
    List<Callable<Object>> callableTodo = new ArrayList<Callable<Object>>();

    // add the callables to the todo list
    callableTodo.add(new MyCallable<Object>());
    callableTodo.add(new MyCallable<Object>());

    // start the threads
    List<Future<Object>> futures = listProcessor.invokeAll(callableTodo);
    listProcessor.shutdown();
    listProcessor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);

    // futures now holds possible exceptions
    for (Future<Object> future : futures) {
     try {
        future.get();
     } catch (ExecutionException e) {
         // process the exception
     }
    }
}