# Print output for @column tags ?>
Developers

- Design
- Develop
- Distribute

Developer Console

## Most visited

## Recently visited

## Results for

Summary: Ctors | Methods | Inherited Methods

# ExecutorCompletionService

`public class ExecutorCompletionService`
`extends Object` `implements CompletionService<V>`

java.lang.Object
↳ | java.util.concurrent.ExecutorCompletionService<V>

A `CompletionService` that uses a supplied `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<>(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);
     }

## Summary

### Public constructors
`ExecutorCompletionService(Executor executor)` Creates an ExecutorCompletionService using the supplied executor for base task execution and a `LinkedBlockingQueue` as a completion queue.
`ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)` Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.

### Public methods
`Future<V>` | `poll(long timeout, TimeUnit unit)` Retrieves and removes the Future representing the next completed task, waiting if necessary up to the specified wait time if none are yet present.
`Future<V>` | `poll()` Retrieves and removes the Future representing the next completed task, or `null` if none are present.
`Future<V>` | `submit(Runnable task, V result)` Submits a Runnable task for execution and returns a Future representing that task.
`Future<V>` | `submit(Callable<V> task)` Submits a value-returning task for execution and returns a Future representing the pending results of the task.
`Future<V>` | `take()` Retrieves and removes the Future representing the next completed task, waiting if none are yet present.

### Inherited methods
From class `java.lang.Object`
`Object` | `clone()` Creates and returns a copy of this object.
`boolean` | `equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void` | `finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>` | `getClass()` Returns the runtime class of this `Object`.
`int` | `hashCode()` Returns a hash code value for the object.
`final void` | `notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void` | `notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String` | `toString()` Returns a string representation of the object.
`final void` | `wait(long timeout, int nanos)` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`final void` | `wait(long timeout)` Causes the current thread to wait until either another thread invokes the `notify()` method or the `notifyAll()` method for this object, or a specified amount of time has elapsed.
`final void` | `wait()` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object.
From interface `java.util.concurrent.CompletionService`
`abstract Future<V>` | `poll(long timeout, TimeUnit unit)` Retrieves and removes the Future representing the next completed task, waiting if necessary up to the specified wait time if none are yet present.
`abstract Future<V>` | `poll()` Retrieves and removes the Future representing the next completed task, or `null` if none are present.
`abstract Future<V>` | `submit(Runnable task, V result)` Submits a Runnable task for execution and returns a Future representing that task.
`abstract Future<V>` | `submit(Callable<V> task)` Submits a value-returning task for execution and returns a Future representing the pending results of the task.
`abstract Future<V>` | `take()` Retrieves and removes the Future representing the next completed task, waiting if none are yet present.

## Public constructors

### ExecutorCompletionService

    public ExecutorCompletionService (Executor executor)

Creates an ExecutorCompletionService using the supplied executor for base task execution and a `LinkedBlockingQueue` as a completion queue.

Parameters
`executor` | `Executor`: the executor to use

Throws
`NullPointerException` | if executor is `null`

### ExecutorCompletionService

    public ExecutorCompletionService (Executor executor,
                    BlockingQueue<Future<V>> completionQueue)

Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.

Parameters
`executor` | `Executor`: the executor to use
`completionQueue` | `BlockingQueue`: the queue to use as the completion queue normally one dedicated for use by this service. This queue is treated as unbounded -- failed attempted `Queue.add` operations for completed tasks cause them not to be retrievable.

Throws
`NullPointerException` | if executor or completionQueue are `null`

## Public methods

### poll

    public Future<V> poll (long timeout,
                    TimeUnit unit)

Retrieves and removes the Future representing the next completed task, waiting if necessary up to the specified wait time if none are yet present.

Parameters
`timeout` | `long`: how long to wait before giving up, in units of `unit`
`unit` | `TimeUnit`: a `TimeUnit` determining how to interpret the `timeout` parameter

Returns
`Future<V>` | the Future representing the next completed task or `null` if the specified waiting time elapses before one is present

Throws
`InterruptedException` |

### poll

    public Future<V> poll ()

Retrieves and removes the Future representing the next completed task, or `null` if none are present.

Returns
`Future<V>` | the Future representing the next completed task, or `null` if none are present

### submit

    public Future<V> submit (Runnable task,
                    V result)

Submits a Runnable task for execution and returns a Future representing that task. Upon completion, this task may be taken or polled.

Parameters
`task` | `Runnable`: the task to submit
`result` | `V`: the result to return upon successful completion

Returns
`Future<V>` | a Future representing pending completion of the task, and whose `get()` method will return the given result value upon completion

### submit

    public Future<V> submit (Callable<V> task)

Submits a value-returning task for execution and returns a Future representing the pending results of the task. Upon completion, this task may be taken or polled.

Parameters
`task` | `Callable`: the task to submit

Returns
`Future<V>` | a Future representing pending completion of the task

### take

    public Future<V> take ()

Retrieves and removes the Future representing the next completed task, waiting if none are yet present.

Returns
`Future<V>` | the Future representing the next completed task

Throws
`InterruptedException` |

Full name *
Email address *
Company / developer name
One of your Play Store app URLs *
Which best describes your business:*
Apps
Games
Apps & Games
*
*