从列表中同时获取所有期货

Question

I have an arraylist of Futures that are executed by an ExecutorService:

ExecutorService executor = Executors.netFixedThreadPoolExecytor(COUNT);
for(myObj : list){
    Future<myObj> future = executor.submit()(() - > some.method(myObj));
    futurelist.add(future);
}
executor.shutdown()

I want to be able to call the get() function for all the Futures in the array at the same time so the Thread won't wait for completion until it takes the next element. The closer I have come is to take all the elements from the array and loop trough them:

for(Future f : futurelist) {
    f.get()
}

How can I make that all the futures to be executed and completed at the same time ?

Answer 1

Await termination of your executor service

Your comments indicate that your real goal is to wait until all your submitted tasks have been completed (or cancelled).

You said:

I want somehow to call get() after all the Futures are completed

A Future does not get completed. A Future represents:

• The status of a Callable / Runnable that may have yet to start execution, may be currently executing, or may have ended its execution.
• The result of a Callable object's work, returned by its call method . The result payload on the . The result payload on the Future` is empty until the task has completed and returned an object.

To wait until all the submitted tasks are done, you simply need to call shutdown and awaitTermination on your executor service.

And by the way, you can submit a collection of Callable objects to your executor service, if that suits your situation. You will get back a collection of Future objects. Getting those Future objects does not mean the tasks are done, it means the tasks were successfully submitted to an executor service. By the time you get a Future back, the task may or may not have started execution.

Here is some example code.

Set up a collection of Callable objects. Our example here returns a UUID .

int countTasks = 10;
List < Callable < UUID > > tasks = new ArrayList <>( countTasks );
for ( int i = 0 ; i < countTasks ; i++ )
{
    Callable < UUID > c = ( ) -> { return UUID.randomUUID(); };
    tasks.add( c );
}

Set up an executor service to perform our tasks on background threads. Establish a List to be filled with Future objects representing each of our task's work.

ExecutorService executorService = Executors.newCachedThreadPool();
List < Future < UUID > > futures = null;

Ask our executor service to perform those tasks. The service collects the instantiated Future objects, returning to us the collection.

try { futures = executorService.invokeAll( tasks ); } catch ( InterruptedException e ) { e.printStackTrace(); }

We immediately ask the executor service to go into shutdown mode. This stops further tasks from being submitted, but allows already-submitted tasks to continue. We then tell the executor service to wait a certain amount of time for all submitted tasks to complete. We check to see if the termination completed or timed-out.

executorService.shutdown();
try
{
    boolean terminationComleted = executorService.awaitTermination( 1 , TimeUnit.MINUTES );
    if ( ! terminationComleted ) System.out.println( "ERROR - Submitted tasks not completed before time-out. " + Instant.now() );
}
catch ( InterruptedException e ) { e.printStackTrace(); }

The call to awaitTermination blocks until either all tasks are done or the time-out is reached. So beyond that call means the executor service is shutdown. So we can now examine our collection of Future objects to see the fruits of our threaded work.

// At this point all submitted tasks are done, and the executor service has ended.
for ( Future < UUID > future : futures )
{
    if ( future.isCancelled() )
    {
        System.out.println( "Oops, task was cancelled. " );
    } else
    {
        try { System.out.println( "future = " + future + "  |  " + future.get() ); } catch ( InterruptedException e ) { e.printStackTrace(); }catch ( ExecutionException e ) { e.printStackTrace(); }
    }
}

Same example, in a complete class, ready to run.

package work.basil.demo.threads;

import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.*;

public class App4
{
    public static void main ( String[] args )
    {
        App4 app = new App4();
        app.demo();
    }

    private void demo ( )
    {
        System.out.println( "INFO - Starting method `demo`. " + Instant.now() );

        int countTasks = 10;
        List < Callable < UUID > > tasks = new ArrayList <>( countTasks );
        for ( int i = 0 ; i < countTasks ; i++ )
        {
            Callable < UUID > c = ( ) -> { return UUID.randomUUID(); };
            tasks.add( c );
        }

        ExecutorService executorService = Executors.newCachedThreadPool();
        List < Future < UUID > > futures = null;
        try { futures = executorService.invokeAll( tasks ); } catch ( InterruptedException e ) { e.printStackTrace(); }

        executorService.shutdown();
        try
        {
            boolean terminationComleted = executorService.awaitTermination( 1 , TimeUnit.MINUTES );
            if ( ! terminationComleted ) System.out.println( "ERROR - Submitted tasks not completed before time-out. " + Instant.now() );
        }
        catch ( InterruptedException e ) { e.printStackTrace(); }
        // At this point all submitted tasks are done, and the executor service has ended.
        for ( Future < UUID > future : futures )
        {
            if ( future.isCancelled() )
            {
                System.out.println( "Oops, task was cancelled. " );
            } else
            {
                try { System.out.println( "future = " + future + "  |  " + future.get() ); } catch ( InterruptedException e ) { e.printStackTrace(); }catch ( ExecutionException e ) { e.printStackTrace(); }
            }
        }

        System.out.println( "INFO - Starting method `demo`. " + Instant.now() );
    }
}

You asked:

How can I make that all the futures to be executed and completed at the same time ?

You cannot.

The first rule of threaded work is that you do not control the threads . When a thread is scheduled for execution on a core, and for how long that execution runs before suspension, all depends on the JVM , the host OS , and the momentary runtime conditions.

Any of your threads may be started at any time, suspended at any time, and completed at any time. The threads may complete in any order at any time.

You said:

I want to be able to call the get() function for all the Futures

You can get all the Future objects as a collection, as shown in the code above. But each Future represents the task to be executed, not the fact that it has been executed. Hence the name Future .

You can ask each Future object if its task is done or not by calling Future#isDone . If the task has not yet begun execution, you get false . If the task is underway (either actively executing on a core or suspended), you get false . If the task has completed its work, been cancelled, or failed from a thrown exception, then you get true .

Answer 2

As far as I know this is not possible to do directly with Future . I would change your tasks to put their result in a queue, and then just read from the queue.

Maybe something like:

List<Object> results = new concurrent list...
Callable<Object> task = new MyTask( results ) // inject list to hold results
List<Callable> taskList = new list...
taskList.add( taskList );
ExecutorService executor = Executors.netFixedThreadPoolExecytor(COUNT);
for(myObj : list){
    Future<myObj> future = executor.submit()(() - > some.method(myObj));
    futurelist.add(future);
}
executor.shutdown();
for( int i = 0; i < COUNT; i++ ) {
   Object result = results.poll();
   // process result...
}