ExecutorService wait for all Future to complete

Question

I have below code for ExecutorService.

try{
    ExecutorService executor = Executors.newFixedThreadPool(5);
    List<Callable<String>> taskList = new ArrayList<Callable<String>>(5);
    for(int i=1;i<=5;i++){
        taskList.add(new SimpleTask());
    }

    List<Future<String>> list =  executor.invokeAll(taskList);
    executor.shutdown();
    System.out.println(list.get(0).get());
    System.out.println("Exit");
}catch(Exception e){
    e.printStackTrace();
}

class SimpleTask implements Callable<String> {
    @Override
    public String call() throws Exception {     
        return new Date().toString();
    }
}

I want to know list.get(0).get() will wait for all task to complete?

No it will wait for just one `Future` (the first one) to complete — Scary Wombat, Apr 12 '18 at 06:38
As Wombat say, no. So, are you asking for ways to do that or does that answer your question? — daniu, Apr 12 '18 at 06:40
I have put breakpoint in call() and skip for first Task. Then also waiting for all Task to complete. — mcacorner, Apr 12 '18 at 06:41
If you put a break point in `call()`, you'll have to skip it five times because that's how often it will be called. That sounds like the reason it's waiting. — daniu, Apr 12 '18 at 06:51

Sunil Kanzar · Accepted Answer · 2018-04-12T09:25:46.657

4

Here code will not wait while execution of list.get(0).get() statement but executor.invokeAll(taskList) statement because invokeAll() method itself will wait for complication of all the threads.

To learn more Answer

edited Apr 12 '18 at 09:25

answered Apr 12 '18 at 08:30

Sunil Kanzar

1,244
1
9
21

score -1 · Answer 2 · answered Apr 12 '18 at 07:26

No, the code as it is will not wait for every task to finish. By calling list.get(0).get() you are retrieving the very first optional call get() on it which will block the thread according to the documentation.

To wait for every callable to finish you need to iterate through the list and see if all are done. Of course you can do this by calling get() on every single one of them but then you would block your main thread the whole time. I myself prefer to being able to do stuff while i am waiting for other threads to execute.

Example using Java 8 streams:

// filter if any future is not done yet
while ( list.stream().anyMatch(i->!i.isDone()) )
{
  // Do whatever you want parallel to the evaluation of the Future objects

  // example
  System.err.println( "Not all are done yet." );
}
// process your results

// example:
String[] results = list.stream().map( Main::evalGet ).toArray(String[]::new);

Note: priavte static <T> TevalGet(Future<T> fu) is just a wrapper function to keep the lambda expression clean of exception-handling and looks similar to this:

private static <T> T evalGet( Future<T> fu )
  {
    T obj = null;
    try
    {
      obj = fu.get();
    }
    catch ( InterruptedException | ExecutionException e )
    {
      e.printStackTrace();
    }
    return obj;
  }

Refer : https://stackoverflow.com/questions/34440604/whether-to-use-invokeall-or-submit-java-executor-service — mcacorner, Apr 12 '18 at 08:28

ExecutorService wait for all Future to complete

2 Answers2