Java 异常情况下如何获取原始数据的引用？

我正在使用ExecutorService运行一些可调用线程。线程在提交到ExecutorService之前用数据初始化

在处理Future.get（）引发的异常时，我希望使用原始数据记录一条消息。是否可以从未来对象返回到创建它的原始线程

伪代码：

void run(List<Data> dataList) {
    List<Future<Foo>> results = new ArrayList<Future<Foo>>();
    for (Data data : dataList) {
        Callable<Foo> thread = new FooCallable(data);
        Future<Foo> result = this.executorService.submit(thread);
        results.add(result);
    }

    ...

    for (Future<Foo> result : results) {
        Foo foo;
        try {
            foo = result.get();
        } catch (InterruptedException e) {
            //
            // I would like access to the original Data object here
            //
        } catch (ExecutionException e) {
            //
            // and here
            //
        }
    }
}

void运行（列表数据列表）{
列表结果=新建ArrayList（）；
用于（数据：数据列表）{
可调用线程=新的可调用（数据）；
未来结果=this.executorService.submit（线程）；
结果。添加（结果）；
}
...
用于（未来结果：结果）{
富富,；
试一试{
foo=result.get（）；
}捕捉（中断异常e）{
//
//我想在这里访问原始数据对象
//
}捕获（执行例外）{
//
//这里呢
//
}
}
}

是否可以从未来对象返回到创建它的原始线程

我认为您的意思是希望访问导致异常的

数据
字段。您可以通过创建一个小容器类来实现这一点：

private static class FutureData {
   final Data data;
   final Future<Foo> future;
   public FutureData(Data data, Future<Foo> future) {
      this.data = data;
      this.future = future;
   }
}

然后你可以做：

for (FutureData futureData : results) {
    Foo foo;
    try {
        foo = futureData.future.get();
    } catch (Exception e) {
       // use futureData.data here
       ...

使用地图而不是列表来存储未来及其相应的数据，并将未来用作该地图的键：

Map<Future<Foo>,Data> results = new HashMap<Future<Foo>,Data>();
for (Data data : dataList) {
    Callable<Foo> thread = new FooCallable(data);
    Future<Foo> result = this.executorService.submit(thread);
    results.put(result,data);
}

Iterator<Map.Entry<Future<Foo>,Data>> resultsIterator = results.entrySet().iterator();
while(resultsIterator.hasNext()) {
    Map.Entry<Future<Foo>,Data> entry = resultsIterator.next();
    Future<Foo> future = entry.getKey();
    Data data = entry.getValue();
    Foo foo;
    try {
        foo = future.get();
    } catch (InterruptedException e) {
        //data accessible here
    } catch (ExecutionException e) {
        //data accessible here too
    }
}

Map results=newhashmap（）；
用于（数据：数据列表）{
可调用线程=新的可调用（数据）；
未来结果=this.executorService.submit（线程）；
结果。输入（结果、数据）；
}
迭代器结果迭代器=results.entrySet（）.Iterator（）；
while（resultsIterator.hasNext（））{
Map.Entry=resultsIterator.next（）；
Future=entry.getKey（）；
数据=entry.getValue（）；
富富,；
试一试{
foo=future.get（）；
}捕捉（中断异常e）{
//可在此访问的数据
}捕获（执行例外）{
//这里也可以访问数据
}
}
FooCallable
是一个
可调用的
，而不是线程。那里的名字令人困惑。
Map<Future<Foo>,Data> results = new HashMap<Future<Foo>,Data>();
for (Data data : dataList) {
    Callable<Foo> thread = new FooCallable(data);
    Future<Foo> result = this.executorService.submit(thread);
    results.put(result,data);
}

Iterator<Map.Entry<Future<Foo>,Data>> resultsIterator = results.entrySet().iterator();
while(resultsIterator.hasNext()) {
    Map.Entry<Future<Foo>,Data> entry = resultsIterator.next();
    Future<Foo> future = entry.getKey();
    Data data = entry.getValue();
    Foo foo;
    try {
        foo = future.get();
    } catch (InterruptedException e) {
        //data accessible here
    } catch (ExecutionException e) {
        //data accessible here too
    }
}