Stay organized with collections Save and categorize content based on your preferences.
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: 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 |
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 |
take
open fun take(): Future<V>!
| Return |
Future<V>! | the Future representing the next completed task |
| Exceptions |
java.lang.InterruptedException | if interrupted while waiting |
Content and code samples on this page are subject to the licenses described in the Content License. Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
Last updated 2025-02-10 UTC.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2025-02-10 UTC."],[],[]]
