ExecutorCompletionService
open class ExecutorCompletionService<V : Any!> : CompletionService<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:
<code>void solve(Executor e,
Collection<Callable<Result>> solvers)
throws InterruptedException, ExecutionException {
CompletionService<Result> cs
= new ExecutorCompletionService<>(e);
solvers.forEach(cs::submit);
for (int i = solvers.size(); i > 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<Callable<Result>> solvers)
throws InterruptedException {
CompletionService<Result> cs
= new ExecutorCompletionService<>(e);
int n = solvers.size();
List<Future<Result>> futures = new ArrayList<>(n);
Result result = null;
try {
solvers.forEach(solver -> futures.add(cs.submit(solver)));
for (int i = n; i > 0; i--) {
try {
Result r = cs.take().get();
if (r != null) {
result = r;
break;
}
} catch (ExecutionException ignore) {}
}
} finally {
futures.forEach(future -> future.cancel(true));
}
if (result != null)
use(result);
}</code>
Summary
Public constructors |
Creates an ExecutorCompletionService using the supplied executor for base task execution and a LinkedBlockingQueue as a completion queue.
|
Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.
|
Public constructors
ExecutorCompletionService
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 |
Exceptions |
java.lang.NullPointerException |
if executor is null |
ExecutorCompletionService
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.
Parameters |
executor |
Executor!: the executor to use |
completionQueue |
BlockingQueue<Future<V>!>!: 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. |
Exceptions |
java.lang.NullPointerException |
if executor or completionQueue are null |
Public methods
poll
open fun poll(): Future<V>!
Return |
Future<V>! |
the Future representing the next completed task, or null if none are present |
poll
open fun poll(
timeout: Long,
unit: TimeUnit!
): Future<V>!
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 |
Return |
Future<V>! |
the Future representing the next completed task or null if the specified waiting time elapses before one is present |
Exceptions |
java.lang.InterruptedException |
if interrupted while waiting |
submit
open fun submit(task: Callable<V>!): Future<V>!
Parameters |
task |
Callable<V>!: the task to submit |
Return |
Future<V>! |
a Future representing pending completion of the task |
Exceptions |
java.util.concurrent.RejectedExecutionException |
if the task cannot be scheduled for execution |
java.lang.NullPointerException |
if the task is null |
submit
open fun submit(
task: Runnable!,
result: V
): Future<V>!
Parameters |
task |
Runnable!: the task to submit |
result |
V: the result to return upon successful completion |
Return |
Future<V>! |
a Future representing pending completion of the task, and whose get() method will return the given result value upon completion |
Exceptions |
java.util.concurrent.RejectedExecutionException |
if the task cannot be scheduled for execution |
java.lang.NullPointerException |
if the task is null |
take
open fun take(): Future<V>!
Return |
Future<V>! |
the Future representing the next completed task |
Exceptions |
java.lang.InterruptedException |
if interrupted while waiting |