Java Concurrency: How can I tell which Future belongs to which Callable during processing?

Question

I have a collection of Callables and a ExecutorService. When I invokeAll, I get back a list of Future objects. How can I tell which Future object mapped to which Callable before the Future completes? I can tell afterwards because the

Code:

 ExecutorService es = .....;

 Collection<Callables> uniqueCallables = .....;  // each Callable is unique!

 List<Future> futures = es.invokeAll(uniqueCallables);

 // TODO--find unique Future A which is the future for Callable A!

Answer 1

Based on Java reference, invokeAll(uniqueCallables) preserves the order in List<Future> as the order produced by uniqueCallables.iterator():

Returns: A list of Futures representing the tasks, in the same sequential order as produced by the iterator for the given task list, each of which has completed.

Answer 2

Sounds like you simply need to be able to lookup the original callable from a Future. If you weren't using invokeAll, you could decorate the Executor wrapping the submit() to create a ContextualFuture that keeps a reference to the original callable.

/*pseudo example*/
class ContextualFuture<RETURN> implements Future<RETURN> {
   private Callable<RETURN> callable;
   private Future<RETURN> wrappedFuture;
   public ContextualFuture(Callable<RETURN> callable, Future<RETURN> future){
       this.callable = callable;
       this.future = future;
   }
   // implemented/wrapped methods 
}

class ContextualThreadPool {
   private ExecutorService wrappedExecutor;
   public <T> ContextualFuture<T> submit(Callable<T> task){
       Future<T> f = wrappedExecutor.submit(task);
       return new ContextualFuture<T>(task, f);
   }
}