Package com.oracle.coherence.concurrent.executor

Interface Task<T>

Type Parameters:

T - the type of result produced by the Task

All Superinterfaces:

ExternalizableLite, Serializable

All Known Implementing Classes:

CronTask, ValueTask

public interface Task<T>
extends ExternalizableLite

A task which may take a long time to execute, may be executed by multiple Executors, may generate intermediate results, and may yield for later execution.

Implementations define a single method called execute(Context) that performs the task, possibly yielding execution to some later point. Once the method has completed execution, by returning a result or throwing an exception (but not a Yield exception), the task is considered completed for the assigned Executor.

Tasks are like Callable and Runnable classes in that they are designed to be potentially executed by one or more Threads, typically Executors. Unlike Callable and Runnable classes, the execution may occur in Java Virtual Machines, fail and/or recover between different Java Virtual Machine processes. As such, it is recommended to account for fail-over if a task is recovered. Important execution state should be saved in the in the Task.Context properties. Tasks should check Task.Context.isResuming() to determine if the task has failed over to another executor and if execution state should be recovered from the Task.Context properties.

Since:

21.12

Author:

bo

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static interface	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.
static interface	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.
static interface	Task.Completable<T,R>	A Task.Collectable that supports performing operations when a Task orchestration is complete.
static interface	Task.CompletionRunnable<T>	A runnable to be called upon task completion.
static interface	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.
static interface	Task.Coordinator<T>	A publisher of collected Task results that additionally permits coordination of the submitted Task.
static interface	Task.Option	An option for configuring Task orchestration.
static interface	Task.Orchestration<T>	Defines information concerning the orchestration of a Task across a set of Executors for a given TaskExecutorService.
static interface	Task.Properties	Define an interface to allow states sharing between the task executors.
static interface	Task.SubscribedOrchestration<T>	Defines the subset of Task.Orchestration methods which are permitted after Task.SubscribedOrchestration.subscribe(Subscriber) is called.
static interface	Task.Subscriber<T>	A receiver of items produced by a Task.Coordinator.
static interface	Task.Subscription<T>	Represents a subscription a Task.Subscriber has made to a Task.Coordinator, allowing control and termination of the Task.Subscription.
static class	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.

Method Summary

Modifier and Type	Method	Description
T	execute(Task.Context<T> context)	Executes the Task.

Methods inherited from interface com.tangosol.io.ExternalizableLite

readExternal, writeExternal

Method Details

execute

T execute(Task.Context<T> context)
   throws Exception

Executes the Task.

Parameters:

context - the Task.Context

Returns:

the result of executing the Task

Throws:

Task.Yield - which indicates the Task execution should yield execution until some later point in time

Exception