ExecutorCompletionService (Java Platform SE 6)

This documentation differs from the official API. Jadeite adds extra features to the API including: variable font sizes, constructions examples, placeholders for classes and methods, and auto-generated “See Also” links. Additionally it is missing some items found in standard Javadoc documentation, including: generics type information, “Deprecated” tags and comments, “See Also” links, along with other minor differences. Please send any questions or feedback to bam@cs.cmu.edu.

Overview

Package

Class

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

java.util.concurrent
class ExecutorCompletionService

java.lang.Object
  java.util.concurrent.ExecutorCompletionService

All Implemented Interfaces:: CompletionService

Most common way to construct:

ExecutorService e = …;

ExecutorCompletionService ecs = new ExecutorCompletionService(e);

Based on 26 examples

public class ExecutorCompletionService
extends Object
implements CompletionService

A {@link CompletionService} that uses a supplied {@link Executor} to execute tasks. This class arranges that submitted tasks are, upon completion, placed on a queue accessible using take. The class is lightweight enough to be suitable for transient use when processing groups of tasks.

Usage Examples. Suppose you have a set of solvers for a certain problem, each returning a value of some type Result, and would like to run them concurrently, processing the results of each of them that return a non-null value, in some method use(Result r). You could write this as:

   void solve(Executor e,
              Collection<Callable<Result>> solvers)
     throws InterruptedException, ExecutionException {
       CompletionService<Result> ecs
           = new ExecutorCompletionService<Result>(e);
       for (Callable<Result> s : solvers)
           ecs.submit(s);
       int n = solvers.size();
       for (int i = 0; i < n; ++i) {
           Result r = ecs.take().get();
           if (r != null)
               use(r);
       }
   }

Suppose instead that you would like to use the first non-null result of the set of tasks, ignoring any that encounter exceptions, and cancelling all other tasks when the first one is ready:

   void solve(Executor e,
              Collection<Callable<Result>> solvers)
     throws InterruptedException {
       CompletionService<Result> ecs
           = new ExecutorCompletionService<Result>(e);
       int n = solvers.size();
       List<Future<Result>> futures
           = new ArrayList<Future<Result>>(n);
       Result result = null;
       try {
           for (Callable<Result> s : solvers)
               futures.add(ecs.submit(s));
           for (int i = 0; i < n; ++i) {
               try {
                   Result r = ecs.take().get();
                   if (r != null) {
                       result = r;
                       break;
                   }
               } catch (ExecutionException ignore) {}
           }
       }
       finally {
           for (Future<Result> f : futures)
               f.cancel(true);
       }

       if (result != null)
           use(result);
   }

Constructor Summary
`ExecutorCompletionService(Executor executor)` Creates an ExecutorCompletionService using the supplied executor for base task execution and a java.util.concurrent.LinkedBlockingQueue as a completion queue.
`ExecutorCompletionService(Executor executor, BlockingQueue completionQueue)` Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.

Method Summary
`Future`	`poll()`
`Future`	`poll(long timeout, TimeUnit unit)`
`Future`	`submit(Callable task)`
`Future`	`submit(Runnable task, Object result)`
`Future`	`take()`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail