org.threadly.concurrent.future

Class ScheduledFutureDelegate<T>

java.lang.Object

org.threadly.concurrent.future.ScheduledFutureDelegate<T>

Type Parameters:

T - The result object type returned by this future

All Implemented Interfaces:

java.lang.Comparable<java.util.concurrent.Delayed>, java.util.concurrent.Delayed, java.util.concurrent.Future<T>, java.util.concurrent.ScheduledFuture<T>, ListenableFuture<T>, ListenableScheduledFuture<T>

public class ScheduledFutureDelegate<T>
extends java.lang.Object
implements ListenableScheduledFuture<T>

Implementation of the ListenableScheduledFuture interface. This design delegates between a Delayed instance and ListenableFuture instance.

Since:

1.0.0

Nested Class Summary

Nested classes/interfaces inherited from interface org.threadly.concurrent.future.ListenableFuture

ListenableFuture.ListenerOptimizationStrategy

Constructor Summary

Constructors

Constructor and Description
ScheduledFutureDelegate(ListenableFuture<? extends T> futureImp, java.util.concurrent.Delayed delayed) Constructs a new ScheduledFutureDelegate with the provided instances to call to for each interface.

Method Summary

Modifier and Type	Method and Description
void	addCallback(FutureCallback<? super T> callback, java.util.concurrent.Executor executor, ListenableFuture.ListenerOptimizationStrategy optimizeExecution) Add a FutureCallback to be called once the future has completed.
void	addListener(java.lang.Runnable listener, java.util.concurrent.Executor executor, ListenableFuture.ListenerOptimizationStrategy optimizeExecution) Add a listener to be called once the future has completed.
boolean	cancel(boolean mayInterruptIfRunning)
int	compareTo(java.util.concurrent.Delayed o)
T	get()
T	get(long timeout, java.util.concurrent.TimeUnit unit)
long	getDelay(java.util.concurrent.TimeUnit unit)
boolean	isCancelled()
boolean	isDone()

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.threadly.concurrent.future.ListenableFuture

addCallback, addCallback, addListener, addListener, flatMap, flatMap, flatMap, map, map, map, throwMap, throwMap, throwMap

Constructor Detail

ScheduledFutureDelegate

public ScheduledFutureDelegate(ListenableFuture<? extends T> futureImp,
                               java.util.concurrent.Delayed delayed)

Constructs a new ScheduledFutureDelegate with the provided instances to call to for each interface.

Parameters:

futureImp - implementation to call to for all Future calls

delayed - implementation to call to for getDelay and compareTo

Method Detail

getDelay

public long getDelay(java.util.concurrent.TimeUnit unit)

Specified by:

getDelay in interface java.util.concurrent.Delayed

compareTo

public int compareTo(java.util.concurrent.Delayed o)

Specified by:

compareTo in interface java.lang.Comparable<java.util.concurrent.Delayed>

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Specified by:

cancel in interface java.util.concurrent.Future<T>

isCancelled

public boolean isCancelled()

Specified by:

isCancelled in interface java.util.concurrent.Future<T>

isDone

public boolean isDone()

Specified by:

isDone in interface java.util.concurrent.Future<T>

get

public T get()
      throws java.lang.InterruptedException,
             java.util.concurrent.ExecutionException

Specified by:

get in interface java.util.concurrent.Future<T>

Throws:

java.lang.InterruptedException

java.util.concurrent.ExecutionException

get

public T get(long timeout,
             java.util.concurrent.TimeUnit unit)
      throws java.lang.InterruptedException,
             java.util.concurrent.ExecutionException,
             java.util.concurrent.TimeoutException

Specified by:

get in interface java.util.concurrent.Future<T>

Throws:

java.lang.InterruptedException

java.util.concurrent.ExecutionException

java.util.concurrent.TimeoutException

addListener

public void addListener(java.lang.Runnable listener,
                        java.util.concurrent.Executor executor,
                        ListenableFuture.ListenerOptimizationStrategy optimizeExecution)

Description copied from interface: ListenableFuture

Add a listener to be called once the future has completed. If the future has already finished, this will be called immediately.

If the provided Executor is null, the listener will execute on the thread which computed the original future (once it is done). If the future has already completed, the listener will execute immediately on the thread which is adding the listener.

Caution should be used when choosing to optimize the listener execution. If the listener is complex, or wanting to be run concurrent, this optimization could prevent that. In addition it will prevent other listeners from potentially being invoked until it completes. However if the listener is small / fast, this can provide significant performance gains. It should also be known that not all ListenableFuture implementations may be able to do such an optimization. Please see ListenableFuture.ListenerOptimizationStrategy javadocs for more specific details of what optimizations are available.

Specified by:

addListener in interface ListenableFuture<T>

Parameters:

listener - the listener to run when the computation is complete

executor - Executor the listener should be ran on, or null

optimizeExecution - true to avoid listener queuing for execution if already on the desired pool

addCallback

public void addCallback(FutureCallback<? super T> callback,
                        java.util.concurrent.Executor executor,
                        ListenableFuture.ListenerOptimizationStrategy optimizeExecution)

Description copied from interface: ListenableFuture

Add a FutureCallback to be called once the future has completed. If the future has already finished, this will be called immediately.

If the provided Executor is null, the callback will execute on the thread which computed the original future (once it is done). If the future has already completed, the callback will execute immediately on the thread which is adding the callback.

Caution should be used when choosing to optimize the listener execution. If the listener is complex, or wanting to be run concurrent, this optimization could prevent that. In addition it will prevent other listeners from potentially being invoked until it completes. However if the listener is small / fast, this can provide significant performance gains. It should also be known that not all ListenableFuture implementations may be able to do such an optimization. Please see ListenableFuture.ListenerOptimizationStrategy javadocs for more specific details of what optimizations are available.

Specified by:

addCallback in interface ListenableFuture<T>

Parameters:

callback - to be invoked when the computation is complete

executor - Executor the callback should be ran on, or null

optimizeExecution - true to avoid listener queuing for execution if already on the desired pool