Added in API level 1

ExecutorCompletionService

open class ExecutorCompletionService<V : Any!> : CompletionService<V>

kotlin.Any
↳	java.util.concurrent.ExecutorCompletionService

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:

<code>void solve(Executor e,
             Collection&lt;Callable&lt;Result&gt;&gt; solvers)
      throws InterruptedException, ExecutionException {
    CompletionService&lt;Result&gt; cs
        = new ExecutorCompletionService&lt;&gt;(e);
    solvers.forEach(cs::submit);
    for (int i = solvers.size(); i &gt; 0; i--) {
      Result r = cs.take().get();
      if (r != null)
        use(r);
    }
  }</code>

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:

<code>void solve(Executor e,
             Collection&lt;Callable&lt;Result&gt;&gt; solvers)
      throws InterruptedException {
    CompletionService&lt;Result&gt; cs
        = new ExecutorCompletionService&lt;&gt;(e);
    int n = solvers.size();
    List&lt;Future&lt;Result&gt;&gt; futures = new ArrayList&lt;&gt;(n);
    Result result = null;
    try {
      solvers.forEach(solver -&gt; futures.add(cs.submit(solver)));
      for (int i = n; i &gt; 0; i--) {
        try {
          Result r = cs.take().get();
          if (r != null) {
            result = r;
            break;
          }
        } catch (ExecutionException ignore) {}
      }
    } finally {
      futures.forEach(future -&gt; future.cancel(true));
    }
 
    if (result != null)
      use(result);
  }</code>

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!, completionQueue: BlockingQueue<Future<V>!>!)` Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.

Public methods
open Future<V>!	`poll()`
open Future<V>!	`poll(timeout: Long, unit: TimeUnit!)`
open Future<V>!	`submit(task: Runnable!, result: V)`
open Future<V>!	`submit(task: Callable<V>!)`
open Future<V>!	`take()`

Public constructors