java.lang.Object
- com.oracle.coherence.concurrent.executor.ClusteredTaskManager<T,A,R>

Type Parameters:

T - the Task type

A - the mutable accumulation type of the reduction operation by the Task.Collector

R - the result type of the reduction operation performed by the Task.Collector

All Implemented Interfaces:

LiveObject, ExternalizableLite, PortableObject, Serializable
```
public class ClusteredTaskManager<T,A,R>
extends Object
implements ExternalizableLite, LiveObject, PortableObject
```
Manages the definition and current state of an individual Task being orchestrated by an TaskExecutorService.

Since:

21.12

Author:

bo

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`class`	`ClusteredTaskManager.AsyncProcessChangesContinuation`	The `ComposableContinuation` to asynchronously process the changes to the `ClusteredTaskManager`.
`static class`	`ClusteredTaskManager.ChainedProcessor`	A `ClusteredTaskManager.ChainedProcessor` executes zero or more contained `InvocableMap.EntryProcessor`s in sequence against a single `InvocableMap.Entry` as a single transaction.
`class`	`ClusteredTaskManager.CleanupContinuation`	A `ComposableContinuation` to clean up the `ClusteredTaskManager`.
`static class`	`ClusteredTaskManager.NotifyExecutionStrategyProcessor`	An `InvocableMap.EntryProcessor` to notify the `Task` that an event has occurred which requires the `ExecutionStrategy` to be re-evaluated.
`static class`	`ClusteredTaskManager.OptimizeExecutionPlanProcessor`	An `InvocableMap.EntryProcessor` to optimize the `ExecutionPlan` for a `Task`.
`static class`	`ClusteredTaskManager.SetActionProcessor`	An `InvocableMap.EntryProcessor` to compare and set the action of a `ExecutionPlan` for a given `Executor`.
`static class`	`ClusteredTaskManager.State`	The state of the `ClusteredTaskManager`.
`static class`	`ClusteredTaskManager.TerminateProcessor`	An `InvocableMap.EntryProcessor` to terminate a running `Task`.
`static class`	`ClusteredTaskManager.UpdateCollectedResultProcessor<T>`	An `PortableAbstractProcessor` to update the collected result for a `Task`.
`static class`	`ClusteredTaskManager.UpdateContributedResultProcessor`	An `InvocableMap.EntryProcessor` to update a contributed `Result` for a specific `Executor`, returning `true` if the update was successful, `false` otherwise.
`static class`	`ClusteredTaskManager.UpdateExecutionPlanProcessor`	An `InvocableMap.EntryProcessor` to update the `ExecutionPlan` for a `Task` after the `ExecutionStrategy` has been evaluated.

Field Summary

Fields
Modifier and Type	Field	Description
`static String`	`CACHE_NAME`	The `NamedCache` in which instance of this class will be placed.
`protected Task.Collector<T,A,R>`	`m_collector`	The `Task.Collector` for the `Task` result(s).
`protected Remote.Predicate<? super R>`	`m_completionPredicate`	The `Remote.Predicate` to determine if the `Task` is complete, based on a collected result.
`protected Task.CompletionRunnable<? super R>`	`m_completionRunnable`	The runnable to call when the `Task` is complete.
`protected int`	`m_cPendingExecutionPlanOptimizationCount`	The number of potential optimizations that can occurred to the `ExecutionPlan` since it was last optimized.
`protected int`	`m_cPendingExecutionStrategyUpdateCount`	The number of events/updates/changes that have occurred since the last time the `ExecutionStrategy` was evaluated, which may impact the `ExecutionPlan`.
`protected Debugging`	`m_debugging`	The `Debugging` option for the `Task`.
`protected ExecutionPlan`	`m_executionPlan`	The current `ExecutionPlan`.
`protected ExecutionStrategy`	`m_executionStrategy`	The `ExecutionStrategy` for executing the `Task` with `Executor`s.
`protected boolean`	`m_fCancelled`	A flag to indicate if the `Task` is now cancelled, in which case no further results will be accepted and no future updates will be published.
`protected boolean`	`m_fCompleted`	A flag to indicate if the `Task` is now completed, in which case no further results will be accepted and no future updates will be published.
`protected boolean`	`m_fRunCompletionRunnable`	A flag to indicate whether to run the completionRunnable or not.
`protected Result<R>`	`m_lastResult`	The last collected result for the `Task`.
`protected long`	`m_lCurrentResultGeneration`	Monotonically increasing generation counter indicating how many times a result was provided.
`protected List<Result<T>>`	`m_listResults`	The list of `Result`s returned by the `Executor`s that are pending processing by the `Task.Collector`.
`protected long`	`m_lProcessedResultGeneration`	The generation counter of the last time the results were evaluated.
`protected long`	`m_lTaskSequence`	The partition based sequence number of the `Task`.
`protected int`	`m_nPartitionId`	The partition ID of the `Task`.
`protected int`	`m_nResultVersion`	The lastResult version represented by a monotonically increasing integer value.
`protected Duration`	`m_retainDuration`	The `Duration` to retain the `Task` after it is complete.
`protected String`	`m_sTaskId`	The unique identity of the `Task`.
`protected ClusteredTaskManager.State`	`m_state`	The current state of the `ClusteredTaskManager`.
`protected Task<T>`	`m_task`	The `Task`.

Constructor Summary

Constructors
Constructor	Description
`ClusteredTaskManager()`	Constructs an `ClusteredTaskManager` (required for serialization).
`ClusteredTaskManager(String sTaskId, Task<T> task, ExecutionStrategy executionStrategy, Task.Collector<? super T,A,R> collector, Remote.Predicate<? super R> completionPredicate, Task.CompletionRunnable<? super R> completionRunnable, Duration retainDuration, OptionsByType<Task.Option> optionsByType)`	Constructs a `ClusteredTaskManager` for the specified `Task`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected boolean`	`asyncEvaluateExecutionStrategy(CacheService service, EnumSet<ExecutionStrategy.EvaluationRationale> rationales)`	Asynchronously evaluate the `ExecutionStrategy` for the `Task` and if necessary, update the `ExecutionPlan` and `Result` map.
`protected boolean`	`asyncEvaluateResult(Result<R> originalResult)`	Evaluate the result of the `Task` given the current `Result`s made by each of the assigned `Executor`(s), returning if a result change occurred.
`void`	`asyncProcessChanges(CacheService service, String key, Cause cause)`	Asynchronously processes the changes that have recently occurred on the `ClusteredTaskManager`.
`protected void`	`cleanProperties(CacheService service)`	Clean up the task properties.
`protected void`	`cleanup(CacheService service, String sKey)`	Cleanup metadata associated with the given task key.
`Task.CompletionRunnable<? super R>`	`getCompletionRunnable()`	Obtains the `Task.CompletionRunnable`.
`Debugging`	`getDebugging()`	Obtains the `Debugging` option of the `Task`.
`Result<R>`	`getLastResult()`	Get the last collected `Result`.
`int`	`getPartitionId()`	Gets the partition ID.
`int`	`getResultVersion()`	Get the version number of the latest result.
`Duration`	`getRetainDuration()`	Obtains the `Duration` to retain the `Task` after it is complete.
`boolean`	`getRunCompletionRunnable()`	Obtains the flag to indicate if we need to run the `Task.CompletionRunnable`.
`ClusteredTaskManager.State`	`getState()`	Obtains the state of the `Task`.
`Task<T>`	`getTask()`	Obtains the `Task` to be executed.
`String`	`getTaskId()`	Obtains the unique identity of the `Task`.
`long`	`getTaskSequence()`	Gets the partition based `Task` sequence number.
`boolean`	`isCancelled()`	Determines if the `Task` has been cancelled.
`boolean`	`isCompleted()`	Determines if the `Task` has completed execution and can now be removed.
`boolean`	`isDone()`	Returns true if the `Task` completed.
`boolean`	`isOwner(String executorId)`	Determines if an `Executor` has been allocated the `Task`.
`ComposableContinuation`	`onDeleted(CacheService service, InvocableMap.Entry entry, Cause cause)`	Effectively a no-op.
`ComposableContinuation`	`onInserted(CacheService service, InvocableMap.Entry entry, Cause cause)`	See `onProcess(CacheService, Entry, Cause)`.
`ComposableContinuation`	`onProcess(CacheService service, InvocableMap.Entry entry, Cause cause)`	Returns a `ComposableContinuation` to invoke based on the current state.
`ComposableContinuation`	`onUpdated(CacheService service, InvocableMap.Entry entry, Cause cause)`	See `onProcess(CacheService, Entry, Cause)`.
`void`	`readExternal(PofReader in)`
`void`	`readExternal(DataInput in)`
`void`	`setExecutionPlan(ExecutionPlan executionPlan)`	Sets the `ExecutionPlan` for the `Task`, replacing any previous plan, without updating any other related state.
`void`	`setPartitionId(int nPartitionId)`	Sets the `Task` partition ID.
`void`	`setResult(String sExecutorId, Result<T> result)`	Updates the `Result` for the specified `Executor`.
`void`	`setRunCompletionRunnable(boolean value)`	Sets the flag to indicate if we need to run the `Task.CompletionRunnable`.
`void`	`setState(ClusteredTaskManager.State state)`	Sets the state of the `Task`.
`void`	`setTaskSequence(long sequence)`	Sets the partition based `Task` sequence number.
`void`	`writeExternal(PofWriter out)`
`void`	`writeExternal(DataOutput out)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - CACHE_NAME
```
public static String CACHE_NAME
```
    The NamedCache in which instance of this class will be placed.
  - m_sTaskId
```
protected String m_sTaskId
```
    The unique identity of the Task.
  - m_lTaskSequence
```
protected long m_lTaskSequence
```
    The partition based sequence number of the Task.
  - m_nPartitionId
```
protected int m_nPartitionId
```
    The partition ID of the Task.
  - m_task
```
protected Task<T> m_task
```
    The Task.
  - m_executionStrategy
```
protected ExecutionStrategy m_executionStrategy
```
    The ExecutionStrategy for executing the Task with Executors.
  - m_collector
```
protected Task.Collector<T,A,R> m_collector
```
    The Task.Collector for the Task result(s).
  - m_completionPredicate
```
protected Remote.Predicate<? super R> m_completionPredicate
```
    The Remote.Predicate to determine if the Task is complete, based on a collected result.
  - m_completionRunnable
```
protected Task.CompletionRunnable<? super R> m_completionRunnable
```
    The runnable to call when the Task is complete.
  - m_fRunCompletionRunnable
```
protected boolean m_fRunCompletionRunnable
```
    A flag to indicate whether to run the completionRunnable or not.
  - m_retainDuration
```
protected Duration m_retainDuration
```
    The Duration to retain the Task after it is complete.
  - m_debugging
```
protected Debugging m_debugging
```
    The Debugging option for the Task.
  - m_executionPlan
```
protected ExecutionPlan m_executionPlan
```
    The current ExecutionPlan. Will be null when is still to be created using the ExecutionStrategy.
  - m_cPendingExecutionStrategyUpdateCount
```
protected int m_cPendingExecutionStrategyUpdateCount
```
    The number of events/updates/changes that have occurred since the last time the ExecutionStrategy was evaluated, which may impact the ExecutionPlan.
  - m_cPendingExecutionPlanOptimizationCount
```
protected int m_cPendingExecutionPlanOptimizationCount
```
    The number of potential optimizations that can occurred to the ExecutionPlan since it was last optimized.
  - m_lastResult
```
protected Result<R> m_lastResult
```
    The last collected result for the Task.
  - m_nResultVersion
```
protected int m_nResultVersion
```
    The lastResult version represented by a monotonically increasing integer value.
  - m_listResults
```
protected List<Result<T>> m_listResults
```
    The list of Results returned by the Executors that are pending processing by the Task.Collector.
  - m_lCurrentResultGeneration
```
protected long m_lCurrentResultGeneration
```
    Monotonically increasing generation counter indicating how many times a result was provided.
  - m_lProcessedResultGeneration
```
protected long m_lProcessedResultGeneration
```
    The generation counter of the last time the results were evaluated.
  - m_fCompleted
```
protected boolean m_fCompleted
```
    A flag to indicate if the Task is now completed, in which case no further results will be accepted and no future updates will be published.
  - m_fCancelled
```
protected boolean m_fCancelled
```
    A flag to indicate if the Task is now cancelled, in which case no further results will be accepted and no future updates will be published.
  - m_state
```
protected ClusteredTaskManager.State m_state
```
    The current state of the ClusteredTaskManager.
- Constructor Detail
  - ClusteredTaskManager
```
public ClusteredTaskManager()
```
    Constructs an ClusteredTaskManager (required for serialization).
  - ClusteredTaskManager
```
public ClusteredTaskManager(String sTaskId,
                            Task<T> task,
                            ExecutionStrategy executionStrategy,
                            Task.Collector<? super T,A,R> collector,
                            Remote.Predicate<? super R> completionPredicate,
                            Task.CompletionRunnable<? super R> completionRunnable,
                            Duration retainDuration,
                            OptionsByType<Task.Option> optionsByType)
```
    Constructs a ClusteredTaskManager for the specified Task.
    
    Parameters:
    
    sTaskId - the unique identity of the Task being managed
    
    task - the Task to manage
    
    executionStrategy - the ExecutionStrategy
    
    collector - the Task.Collector for results
    
    completionPredicate - the Remote.Predicate to determine if a Task is complete
    
    completionRunnable - the Task.CompletionRunnable to call when a Task is complete
    
    retainDuration - the Duration to retain a Task after it is complete
    
    optionsByType - the OptionsByType to be used
- Method Detail
  - onProcess
```
public ComposableContinuation onProcess(CacheService service,
                                        InvocableMap.Entry entry,
                                        Cause cause)
```
    Returns a ComposableContinuation to invoke based on the current state. This may return null if no continuation is needed.
    
    Parameters:
    
    service - the associated CacheService
    
    entry - the cache InvocableMap.Entry for the task being processed
    
    cause - the Cause triggered an update
    
    Returns:
  - isOwner
```
public boolean isOwner(String executorId)
```
    Determines if an Executor has been allocated the Task.
    
    Parameters:
    
    executorId - the Executor ID
    
    Returns:
    
    true if the Executor with the specified identifier has been allocated the Task, false otherwise.
  - getTaskId
```
public String getTaskId()
```
    Obtains the unique identity of the Task.
    
    Returns:
    
    the unique identity of the Task
  - getState
```
public ClusteredTaskManager.State getState()
```
    Obtains the state of the Task.
    
    Returns:
    
    the state of the Task
  - setState
```
public void setState(ClusteredTaskManager.State state)
```
    Sets the state of the Task.
    
    Parameters:
    
    state - the state to set to
  - getRunCompletionRunnable
```
public boolean getRunCompletionRunnable()
```
    Obtains the flag to indicate if we need to run the Task.CompletionRunnable.
    
    Returns:
    
    the flag to indicate if we need to run the Task.CompletionRunnable.
  - setRunCompletionRunnable
```
public void setRunCompletionRunnable(boolean value)
```
    Sets the flag to indicate if we need to run the Task.CompletionRunnable.
    
    Parameters:
    
    value - the flag to indicate if we need to run the Task.CompletionRunnable
  - getCompletionRunnable
```
public Task.CompletionRunnable<? super R> getCompletionRunnable()
```
    Obtains the Task.CompletionRunnable.
    
    Returns:
    
    the Task.CompletionRunnable
  - getRetainDuration
```
public Duration getRetainDuration()
```
    Obtains the Duration to retain the Task after it is complete.
    
    Returns:
    
    the Duration
  - getDebugging
```
public Debugging getDebugging()
```
    Obtains the Debugging option of the Task.
    
    Returns:
    
    the Debugging option
  - asyncProcessChanges
```
public void asyncProcessChanges(CacheService service,
                                String key,
                                Cause cause)
```
    Asynchronously processes the changes that have recently occurred on the ClusteredTaskManager.
    
    Parameters:
    
    service - the CacheService that owns the ClusteredTaskManager state
    
    key - the NamedCache key for the ClusteredTaskManager
    
    cause - the underlying event Cause that triggered the processing
  - getTask
```
public Task<T> getTask()
```
    Obtains the Task to be executed.
    
    Returns:
    
    the Task
  - isCompleted
```
public boolean isCompleted()
```
    Determines if the Task has completed execution and can now be removed.
    
    Returns:
    
    true if the Task has completed execution, false otherwise
  - isCancelled
```
public boolean isCancelled()
```
    Determines if the Task has been cancelled.
    
    Returns:
    
    true if the Task has been cancelled, false otherwise
  - isDone
```
public boolean isDone()
```
    Returns true if the Task completed. Completion may be due to normal termination, an exception, or cancellation -- in all of these cases, this method will return true.
    
    Returns:
    
    true the associated Task has is done false otherwise
  - getLastResult
```
public Result<R> getLastResult()
```
    Get the last collected Result.
    
    Returns:
    
    the last collected Result
  - getResultVersion
```
public int getResultVersion()
```
    Get the version number of the latest result.
    
    Returns:
    
    the version number of the latest result
  - setResult
```
public void setResult(String sExecutorId,
                      Result<T> result)
```
    Updates the Result for the specified Executor.
    
    Parameters:
    
    sExecutorId - the identity of the Executor
    
    result - the Result for the Executor
  - setExecutionPlan
```
public void setExecutionPlan(ExecutionPlan executionPlan)
```
    Sets the ExecutionPlan for the Task, replacing any previous plan, without updating any other related state.
    
    Parameters:
    
    executionPlan - the ExecutionPlan
  - getPartitionId
```
public int getPartitionId()
```
    Gets the partition ID.
    
    Returns:
    
    the partition ID.
  - setPartitionId
```
public void setPartitionId(int nPartitionId)
```
    Sets the Task partition ID.
    
    Parameters:
    
    nPartitionId - the Task partition ID to set to
  - getTaskSequence
```
public long getTaskSequence()
```
    Gets the partition based Task sequence number.
    
    Returns:
    
    the partition based Task sequence number
  - setTaskSequence
```
public void setTaskSequence(long sequence)
```
    Sets the partition based Task sequence number.
    
    Parameters:
    
    sequence - the Task sequence number to set to
  - readExternal
```
public void readExternal(DataInput in)
                  throws IOException
```
    Specified by:
    
    readExternal in interface ExternalizableLite
    
    Throws:
    
    IOException
  - writeExternal
```
public void writeExternal(DataOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface ExternalizableLite
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(PofReader in)
                  throws IOException
```
    Specified by:
    
    readExternal in interface PortableObject
    
    Throws:
    
    IOException
  - writeExternal
```
public void writeExternal(PofWriter out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface PortableObject
    
    Throws:
    
    IOException
  - asyncEvaluateResult
```
protected boolean asyncEvaluateResult(Result<R> originalResult)
```
    Evaluate the result of the Task given the current Results made by each of the assigned Executor(s), returning if a result change occurred.
    
    Parameters:
    
    originalResult - the original Result to evaluate
    
    Returns:
    
    true if a new result is available, false otherwise
  - asyncEvaluateExecutionStrategy
```
protected boolean asyncEvaluateExecutionStrategy(CacheService service,
                                                 EnumSet<ExecutionStrategy.EvaluationRationale> rationales)
```
    Asynchronously evaluate the ExecutionStrategy for the Task and if necessary, update the ExecutionPlan and Result map.
    
    Parameters:
    
    service - the CacheService to use for accessing ClusteredExecutorService caches
    
    rationales - the ExecutionStrategy.EvaluationRationale
    
    Returns:
    
    true if the ExecutionPlan was changed as part of evaluating, false otherwise
  - cleanup
```
protected void cleanup(CacheService service,
                       String sKey)
```
    Cleanup metadata associated with the given task key.
    
    Parameters:
    
    service - the associated CacheService
    
    sKey - the task key
  - cleanProperties
```
protected void cleanProperties(CacheService service)
```
    Clean up the task properties.
    
    Parameters:
    
    service - the CacheService
  - onInserted
```
public ComposableContinuation onInserted(CacheService service,
                                         InvocableMap.Entry entry,
                                         Cause cause)
```
    See onProcess(CacheService, Entry, Cause).
    
    Specified by:
    
    onInserted in interface LiveObject
    
    Parameters:
    
    service - the CacheService for the LiveObject
    
    entry - the entry being inserted
    
    cause - the Cause of the Event
    
    Returns:
    
    an optional ComposableContinuation to be performed asynchronously for the LiveObject (may be null)
    
    See Also:
    
    onProcess(CacheService, Entry, Cause)
  - onUpdated
```
public ComposableContinuation onUpdated(CacheService service,
                                        InvocableMap.Entry entry,
                                        Cause cause)
```
    See onProcess(CacheService, Entry, Cause).
    
    Specified by:
    
    onUpdated in interface LiveObject
    
    Parameters:
    
    service - the CacheService for the LiveObject
    
    entry - the entry being updated
    
    cause - the Cause of the Event
    
    Returns:
    
    an optional ComposableContinuation to be performed asynchronously for the LiveObject (may be null)
    
    See Also:
    
    onProcess(CacheService, Entry, Cause)
  - onDeleted
```
public ComposableContinuation onDeleted(CacheService service,
                                        InvocableMap.Entry entry,
                                        Cause cause)
```
    Effectively a no-op.
    
    Specified by:
    
    onDeleted in interface LiveObject
    
    Parameters:
    
    service - the CacheService for the LiveObject
    
    entry - the entry being deleted
    
    cause - the Cause of the Event
    
    Returns:
    
    an optional ComposableContinuation to be performed asynchronously for the LiveObject (may be null)

Class ClusteredTaskManager<T,​A,​R>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CACHE_NAME

m_sTaskId

m_lTaskSequence

m_nPartitionId

m_task

m_executionStrategy

m_collector

m_completionPredicate

m_completionRunnable

m_fRunCompletionRunnable

m_retainDuration

m_debugging

m_executionPlan

m_cPendingExecutionStrategyUpdateCount

m_cPendingExecutionPlanOptimizationCount

m_lastResult

m_nResultVersion

m_listResults

m_lCurrentResultGeneration

m_lProcessedResultGeneration

m_fCompleted

m_fCancelled

m_state

Constructor Detail

ClusteredTaskManager

ClusteredTaskManager

Method Detail

onProcess

isOwner

getTaskId

getState

setState

getRunCompletionRunnable

setRunCompletionRunnable

getCompletionRunnable

getRetainDuration

getDebugging

asyncProcessChanges

getTask

isCompleted

isCancelled

isDone

getLastResult

getResultVersion

setResult

setExecutionPlan

getPartitionId

setPartitionId

getTaskSequence

setTaskSequence

readExternal

writeExternal

readExternal

writeExternal

asyncEvaluateResult

asyncEvaluateExecutionStrategy

cleanup

cleanProperties

onInserted

onUpdated

onDeleted

Class ClusteredTaskManager<T,A,R>