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<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);
}
poll
public Future poll()
Retrieves and removes the Future representing the next
completed task or null if none are present.
- poll in interface CompletionService
- the Future representing the next completed task, or
null if none are present
poll
public Future poll(long timeout,
TimeUnit unit)
throws InterruptedException
Retrieves and removes the Future representing the next
completed task, waiting if necessary up to the specified wait
time if none are yet present.
- poll in interface CompletionService
timeout
- how long to wait before giving up, in units of
unitunit
- a TimeUnit determining how to interpret the
timeout parameter
- the Future representing the next completed task or
null if the specified waiting time elapses
before one is present
submit
public Future submit(Runnable task,
Object result)
Submits a Runnable task for execution and returns a Future
representing that task. Upon completion, this task may be
taken or polled.
- submit in interface CompletionService
task
- the task to submitresult
- the result to return upon successful completion
- a Future representing pending completion of the task,
and whose get() method will return the given
result value upon completion
submit
public Future submit(Callable 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.
- submit in interface CompletionService
task
- the task to submit
- a Future representing pending completion of the task
take
public Future take()
throws InterruptedException
Retrieves and removes the Future representing the next
completed task, waiting if none are yet present.
- take in interface CompletionService
- the Future representing the next completed task