java.lang.Object
- com.oracle.coherence.concurrent.executor.AbstractTaskCoordinator<T>

Type Parameters:

T - the type of the Task

All Implemented Interfaces:

Task.Coordinator<T>

Direct Known Subclasses:

ClusteredTaskCoordinator
```
public abstract class AbstractTaskCoordinator<T>
extends Object
implements Task.Coordinator<T>
```
A base implementation of a Task.Coordinator.

Since:

21.12

Author:

bo

Field Summary

Fields
Modifier and Type	Field	Description
`protected AtomicBoolean`	`f_cancelled`	Has the `Task` been cancelled.
`protected AtomicBoolean`	`f_closed`	Is the `Task.Coordinator` closed to accept more subscribers or offers of items.
`protected ExecutorService`	`f_executorService`	The `ExecutorService` from the `TaskExecutorService` for asynchronously publishing items.
`protected boolean`	`f_fRetainTask`	The flag to indicate whether the `Task` is retained.
`protected String`	`f_sTaskId`	The unique identity of the `Task`.
`protected Result<T>`	`m_lastValue`	The last value offered (that we'll offer to new `Task.Subscriber`s).
`protected Set<Task.Subscriber<? super T>>`	`m_setSubscribers`	The `Task.Subscriber`s to which items will be published.

Constructor Summary

Constructors
Constructor	Description
`AbstractTaskCoordinator(String taskId, ExecutorService executorService, boolean fRetainTask)`	Construct an `AbstractTaskCoordinator`.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`cancel(boolean mayInterruptIfRunning)`	Attempts to cancel execution of the `Task`.
`void`	`close()`	Closes the `AbstractTaskCoordinator` and notifies the `Task.Subscriber`s that there will no longer be any further items by calling `Task.Subscriber.onComplete()`.
`protected void`	`closeSubscriber(Task.Subscriber<? super T> subscriber, boolean fRemove)`	A helper method to close a `Task.Subscriber` using the calling `Thread`.
`String`	`getTaskId()`	Obtains the unique identity of the `Task` being coordinated.
`boolean`	`hasSubscribers()`	Determine if the `AbstractTaskCoordinator` currently has any `Task.Subscriber`s.
`boolean`	`isCancelled()`	Returns `true` if the `Task` was cancelled before it completed normally.
`boolean`	`isDone()`	Returns `true` if the `Task` completed.
`void`	`offer(Result<T> item)`	Offers an item to be asynchronously published to current `Task.Subscriber`s.
`void`	`subscribe(Task.Subscriber<? super T> subscriber)`	Subscribes the specified `Task.Subscriber` to the `Task.Coordinator` of a `Task` to receive collected results.
`protected abstract void`	`subscribeRetainedTask(Task.Subscriber<?> subscriber)`	Subscribes to a retained task (a task that has completed execution, but it still held in memory).

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

Methods inherited from interface com.oracle.coherence.concurrent.executor.Task.Coordinator
getProperties

- Field Detail
  - f_executorService
```
protected final ExecutorService f_executorService
```
    The ExecutorService from the TaskExecutorService for asynchronously publishing items.
  - f_sTaskId
```
protected final String f_sTaskId
```
    The unique identity of the Task.
  - f_fRetainTask
```
protected final boolean f_fRetainTask
```
    The flag to indicate whether the Task is retained.
  - f_closed
```
protected final AtomicBoolean f_closed
```
    Is the Task.Coordinator closed to accept more subscribers or offers of items.
  - f_cancelled
```
protected final AtomicBoolean f_cancelled
```
    Has the Task been cancelled.
  - m_setSubscribers
```
protected Set<Task.Subscriber<? super T>> m_setSubscribers
```
    The Task.Subscribers to which items will be published.
  - m_lastValue
```
protected volatile Result<T> m_lastValue
```
    The last value offered (that we'll offer to new Task.Subscribers).
- Constructor Detail
  - AbstractTaskCoordinator
```
public AbstractTaskCoordinator(String taskId,
                               ExecutorService executorService,
                               boolean fRetainTask)
```
    Construct an AbstractTaskCoordinator.
    
    Parameters:
    
    taskId - Task ID
    
    executorService - ExecutorService to use for async notifications to Task.Coordinators
    
    fRetainTask - whether to retain the Task after completion
- Method Detail
  - getTaskId
```
public String getTaskId()
```
    Description copied from interface: Task.Coordinator
    
    Obtains the unique identity of the Task being coordinated.
    
    Specified by:
    
    getTaskId in interface Task.Coordinator<T>
    
    Returns:
    
    the task identity
  - cancel
```
public boolean cancel(boolean mayInterruptIfRunning)
```
    Description copied from interface: Task.Coordinator
    
    Attempts to cancel execution of the Task. This attempt will fail if the task has already completed, has already been cancelled, or could not be cancelled for some other reason. If successful, and this task has not started when cancel is called, this task should never run. If the task has already started, then the mayInterruptIfRunning parameter determines whether the thread executing this task should be interrupted in an attempt to stop the task.
    After this method returns, subsequent calls to isDone() will always return true. Subsequent calls to isDone() will always return true if this method returned true.
    Based on https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html#cancel(boolean)
    
    Specified by:
    
    cancel in interface Task.Coordinator<T>
    
    Parameters:
    
    mayInterruptIfRunning - true if the thread executing this task should be interrupted; otherwise, in-progress tasks are allowed to complete
    
    Returns:
    
    false if the task could not be cancelled, typically because it has already completed normally; true otherwise
  - isCancelled
```
public boolean isCancelled()
```
    Description copied from interface: Task.Coordinator
    
    Returns true if the Task was cancelled before it completed normally.
    Based on https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html#isCancelled()
    
    Specified by:
    
    isCancelled in interface Task.Coordinator<T>
    
    Returns:
    
    true if this task was cancelled before it completed
  - isDone
```
public boolean isDone()
```
    Description copied from interface: Task.Coordinator
    
    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.
    Based on https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html#isDone()
    
    Specified by:
    
    isDone in interface Task.Coordinator<T>
    
    Returns:
    
    true if this task completed
  - subscribe
```
public void subscribe(Task.Subscriber<? super T> subscriber)
```
    Description copied from interface: Task.Coordinator
    
    Subscribes the specified Task.Subscriber to the Task.Coordinator of a Task to receive collected results.
    If already subscribed, or the attempt to subscribe fails, the Task.Subscriber.onError(Throwable) method is invoked with an IllegalStateException.
    
    Specified by:
    
    subscribe in interface Task.Coordinator<T>
    
    Parameters:
    
    subscriber - the Task.Subscriber
  - closeSubscriber
```
protected void closeSubscriber(Task.Subscriber<? super T> subscriber,
                               boolean fRemove)
```
    A helper method to close a Task.Subscriber using the calling Thread.
    Closing a Task.Subscriber involves calling either Task.Subscriber.onComplete() or Task.Subscriber.onError(Throwable) when an error occurred.
    
    Parameters:
    
    subscriber - the Task.Subscriber
    
    fRemove - true if the Task.Subscriber should additionally be removed from the Task.Coordinator,false otherwise
  - close
```
public void close()
```
    Closes the AbstractTaskCoordinator and notifies the Task.Subscribers that there will no longer be any further items by calling Task.Subscriber.onComplete().
  - hasSubscribers
```
public boolean hasSubscribers()
```
    Determine if the AbstractTaskCoordinator currently has any Task.Subscribers.
    
    Returns:
    
    true if the AbstractTaskCoordinator has Task.Subscribers, false otherwise
  - offer
```
public void offer(Result<T> item)
```
    Offers an item to be asynchronously published to current Task.Subscribers.
    
    Parameters:
    
    item - the item
  - subscribeRetainedTask
```
protected abstract void subscribeRetainedTask(Task.Subscriber<?> subscriber)
```
    Subscribes to a retained task (a task that has completed execution, but it still held in memory).
    
    Parameters:
    
    subscriber - the subscriber
    
    Throws:
    
    IllegalStateException - if there is no task to subscribe to

Class AbstractTaskCoordinator<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.oracle.coherence.concurrent.executor.Task.Coordinator

Field Detail

f_executorService

f_sTaskId

f_fRetainTask

f_closed

f_cancelled

m_setSubscribers

m_lastValue

Constructor Detail

AbstractTaskCoordinator

Method Detail

getTaskId

cancel

isCancelled

isDone

subscribe

closeSubscriber

close

hasSubscribers

offer

subscribeRetainedTask