com.oracle.coherence.concurrent.executor (Java API Reference for Oracle® Coherence Community Edition)

Classes to allow submission of tasks to the grid for execution.

Since:: 21.12

Interface Summary
Interface	Description
ComposableContinuation	This extension allows composition of Continuations.
ExecutionPlan	Defines proposed `ExecutionPlan.Action`s for assigning a `Task` to zero or more `Executor`s for execution.
ExecutionStrategy	Analyzes current runtime information to define an `ExecutionPlan` for executing a `Task` with available `Executor`s.
RemoteExecutor	A RemoteExecutor allows submitting and/or scheduling `runnables` and `callables` for execution within a Coherence cluster.
Task<T>	A task that may take a long time to execute, may be executed by multiple `Executor`s, may generate intermediate results, and may yield for later execution.
Task.Collectable<T,R>	Provides the mechanism to submit, orchestrate and collect results from a `Task` defined as part of an `Task.Orchestration`, including the creation of a `Task.Coordinator` to subscribe to results, manage and interact with an orchestrated `Task`.
Task.Collector<T,A,R>	A mutable reduction operation that accumulates results into a mutable result container, optionally transforming the accumulated result into a final representation after all results have been processed.
Task.Completable<T,R>	A `Task.Collectable` that supports performing operations when a `Task` orchestration is complete.
Task.CompletionRunnable<T>	A runnable to be called upon task completion.
Task.Context<T>	Provides contextual information for a `Task` as it is executed, including the ability to access and update intermediate results for the `Executor` executing the said `Task`.
Task.Coordinator<T>	A publisher of collected `Task` results that additionally permits coordination of the submitted `Task`.
Task.Option	An option for configuring `Task` orchestration.
Task.Orchestration<T>	Defines information concerning the orchestration of a `Task` across a set of `Executor`s for a given `TaskExecutorService`.
Task.Properties	Define an interface to allow states sharing between the task executors.
Task.SubscribedOrchestration<T>	Defines the subset of `Task.Orchestration` methods which are permitted after `Task.SubscribedOrchestration.subscribe(Subscriber)` is called.
Task.Subscriber<T>	A receiver of items produced by a `Task.Coordinator`.
Task.Subscription<T>	Represents a subscription a `Task.Subscriber` has made to a `Task.Coordinator`, allowing control and termination of the `Task.Subscription`.
TaskExecutorService	An `ExecutorService` that orchestrates execution of submitted executables, for example `Runnable`s, `Callable`s and `Task`s, across zero or more registered `ExecutorService`s.
TaskExecutorService.ExecutorInfo	Provides access to the currently available information for a registered `ExecutorService`.
TaskExecutorService.Registration	Provides registration information about an `ExecutorService` registration.
TaskExecutorService.Registration.Option	An `TaskExecutorService.Registration.Option` for an `ExecutorService` when registered.

Class Summary
Class	Description
AbstractCollectable<T,R,O extends AbstractOrchestration<T,?>>	A base implementation of a `Task.Collectable` and `Task.Completable`.
AbstractCollector<T,R>	An abstract `Task.Collector`.
AbstractOrchestration<T,C extends TaskExecutorService>	A base implementation of a `Task.Orchestration`.
AbstractTaskCoordinator<T>	A base implementation of a `Task.Coordinator`.
ClusteredAssignment	Represents the state of a `Task` assignment to a registered `Executor`.
ClusteredAssignment.AssignmentProcessor	An `InvocableMap.EntryProcessor` which updates an assignment due to an assignment `ExecutionPlan.Action`.
ClusteredAssignment.SetStateProcessor	An `InvocableMap.EntryProcessor` to compare and set the state of a `ClusteredAssignment`, returning the previous state.
ClusteredExecutorInfo	A Coherence-based implementation of a `TaskExecutorService.ExecutorInfo`.
ClusteredExecutorInfo.ClosingContinuation	A `ComposableContinuation` to close a `ClusteredExecutorInfo`, including cleaning up assigned `Task`s.
ClusteredExecutorInfo.ClosingGracefullyContinuation	A `ComposableContinuation` to gracefully close a `ClusteredExecutorInfo`, allowing already assigned `Task`s to complete.
ClusteredExecutorInfo.JoiningContinuation	A `ComposableContinuation` to commence orchestrating a new `Executor` with existing `Task`s.
ClusteredExecutorInfo.RemoveContinuation	A `ComposableContinuation` to remove a `ClusteredExecutorInfo`.
ClusteredExecutorInfo.SetStateProcessor	An `InvocableMap.EntryProcessor` to compare and set the state of a `ClusteredExecutorInfo`, returning the previous state.
ClusteredExecutorInfo.TouchProcessor	An `InvocableMap.EntryProcessor` to update the last update timestamp of a `ClusteredExecutorInfo`.
ClusteredExecutorInfo.TouchRunnable	A `Runnable` to asynchronously touch.
ClusteredExecutorInfo.UpdateInfoProcessor	An `InvocableMap.EntryProcessor` to update the state of an `TaskExecutorService.ExecutorInfo`.
ClusteredExecutorInfo.UpdateInfoRunnable	A `Runnable` to asynchronously update the state of `ClusteredExecutorInfo` using the information based on the current `Runtime`.
ClusteredExecutorService	An Oracle Coherence based `TaskExecutorService`.
ClusteredExecutorService.CESRunnableFuture<V>	`CESRunnableFuture` is a holder for the Callable or Runnable which will be executed by `ClusteredExecutorService.execute(Remote.Runnable)`.
ClusteredOrchestration<T>	A clustered implementation of a `Task.Orchestration`.
ClusteredProperties	A clustered implementation of a `Task.Properties`.
ClusteredProperties.PropertyKey	Property key.
ClusteredProperties.PropertyValue	Property value.
ClusteredRegistration	A cluster-based implementation of an `TaskExecutorService.Registration`.
ClusteredTaskCoordinator<T>	An implementation of a `Task.Coordinator` for Coherence-based implementation.
ClusteredTaskManager<T,A,R>	Manages the definition and current state of an individual `Task` being orchestrated by an `TaskExecutorService`.
ClusteredTaskManager.ChainedProcessor	A `ClusteredTaskManager.ChainedProcessor` executes zero or more contained `InvocableMap.EntryProcessor`s in sequence against a single `InvocableMap.Entry` as a single transaction.
ClusteredTaskManager.NotifyExecutionStrategyProcessor	An `InvocableMap.EntryProcessor` to notify the `Task` that an event has occurred which requires the `ExecutionStrategy` to be re-evaluated.
ClusteredTaskManager.OptimizeExecutionPlanProcessor	An `InvocableMap.EntryProcessor` to optimize the `ExecutionPlan` for a `Task`.
ClusteredTaskManager.SetActionProcessor	An `InvocableMap.EntryProcessor` to compare and set the action of a `ExecutionPlan` for a given `Executor`.
ClusteredTaskManager.TerminateProcessor	An `InvocableMap.EntryProcessor` to terminate a running `Task`.
ClusteredTaskManager.UpdateCollectedResultProcessor<T>	An `PortableAbstractProcessor` to update the collected result for a `Task`.
ClusteredTaskManager.UpdateContributedResultProcessor	An `InvocableMap.EntryProcessor` to update a contributed `Result` for a specific `Executor`, returning `true` if the update was successful, `false` otherwise.
ClusteredTaskManager.UpdateExecutionPlanProcessor	An `InvocableMap.EntryProcessor` to update the `ExecutionPlan` for a `Task` after the `ExecutionStrategy` has been evaluated.
ConditionalCollector<T,A,R>	A `Task.Collector` that conditionally collects values based on the available result.
ContinuationService<T>	A service for tracking, composing and executing `ComposableContinuation`s.
ExecutionStrategyBuilder	A builder of `ExecutionStrategy`s.
MutableExecutionPlan	A mutable implementation of `ExecutionPlan`.
PortableAbstractProcessor	A portable `AbstractProcessor`. a convenience interface for implementations having no properties to serialize.
RecoveringTask	A `Task` that runs for at least a specified `Duration`, returning the resuming / recovering status when completed.
Result<T>	An immutable container representing an intermediate or final result produced by executing a `Task`, typically by an individual `Executor`, including no result, a specific value or a `Throwable`.
StandardExecutionStrategy	An `ExecutionStrategy` that creates `ExecutionPlan`s for executing a `Task` on a number of available `Executor`s that satisfy a specified `Remote.Predicate`.
TaskCollectors	Static helper methods to create `Task.Collector`s.
TaskCollectors.CountCollector<T>	A `Task.Collector` that counts the number of results are present.
TaskCollectors.FirstOfCollector<T>	A `Task.Collector` to collect any (the first provided) available result.
TaskCollectors.LastOfCollector<T>	A `Task.Collector` that collects and returns the last contributed result.
TaskCollectors.ListOfCollector<T>	A `Task.Collector` that collects and returns all contributed results that are values as a `List`.
TaskCollectors.SetOfCollector<T>	A `Task.Collector` that collects and returns all contributed results that are values as a `Set`.
TaskProperties	A basic implementation of a `Task.Properties`.

Enum Summary
Enum	Description
ClusteredAssignment.State	The current state of the assignment.
ClusteredExecutorService.State	Enumeration representing possible state transitions of the `ClusteredExecutorService`.
ClusteredTaskManager.State	The state of the `ClusteredTaskManager`.
ExecutionPlan.Action	A proposed `ExecutionPlan.Action` for an `Executor`.
ExecutionStrategy.EvaluationRationale	A rationale for evaluating an `ExecutionStrategy`.
TaskExecutorService.ExecutorInfo.State	The state of an `ExecutorService`.

Exception Summary
Exception	Description
Task.Yield	An exception signalling the execution of a `Task` by an `Executor` is to be suspended and resumed at some later point in time, typically by the same `Executor`.

Package com.oracle.coherence.concurrent.executor