net.tascalate.concurrent

Class CompletableTask<T>

java.lang.Object

net.tascalate.concurrent.PromiseAdapter<T>

net.tascalate.concurrent.CompletableTask<T>

Type Parameters:

T - a type of the successfully executed task result

All Implemented Interfaces:

CompletionStage<T>, Future<T>, Promise<T>

public class CompletableTask<T>
extends PromiseAdapter<T>

Concrete implementation of Promise interface for long-running blocking tasks

Author:

vsilaev

Field Summary

Fields

Modifier and Type	Field and Description
protected RunnableFuture<T>	task

Fields inherited from class net.tascalate.concurrent.PromiseAdapter

SAME_THREAD_EXECUTOR

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	CompletableTask(Executor executor, Callable<T> callable) Creates a CompletableTask; for internal use only

Method Summary

Modifier and Type	Method and Description
Promise<Void>	acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action, Executor executor)
<U> Promise<U>	applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T,U> fn, Executor executor)
static Promise<Void>	asyncOn(Executor executor) Returns a resolved no-value Promise that is "bound" to the specified executor.
static Promise<Void>	asyncOn(Executor executor, boolean enforceDefaultAsync) Returns a resolved no-value Promise that is "bound" to the specified executor.
boolean	cancel(boolean mayInterruptIfRunning)
static <T> Promise<T>	completed(T value, Executor defaultExecutor) Returns a resolved Promise with specified value; the promise is "bound" to the specified executor.
protected static <V,R> Function<V,R>	consumerAsFunction(Consumer<? super V> action)
protected <U> net.tascalate.concurrent.AbstractCompletableTask<U>	createCompletionStage(Executor executor) Creates a nested sub-task for a composition method
static Promise<Duration>	delay(Duration duration, Executor executor)
static Promise<Duration>	delay(long timeout, TimeUnit unit, Executor executor)
protected <R,U> Promise<U>	doApplyToEitherAsync(CompletionStage<? extends R> first, CompletionStage<? extends R> second, Function<? super R,U> fn, Executor executor) This method exists just to reconcile generics when called from runAfterEitherAsync(java.util.concurrent.CompletionStage<?>, java.lang.Runnable, java.util.concurrent.Executor) which has unexpected type of parameter "other".
Promise<T>	exceptionallyAsync(Function<Throwable,? extends T> fn, Executor executor)
Promise<T>	exceptionallyComposeAsync(Function<Throwable,? extends CompletionStage<T>> fn, Executor executor)
protected static <U> Function<Throwable,U>	forwardException()
protected static <U> U	forwardException(Throwable e)
T	get()
T	get(long timeout, TimeUnit unit)
<U> Promise<U>	handleAsync(BiFunction<? super T,Throwable,? extends U> fn, Executor executor)
boolean	isCancelled()
boolean	isCompletedExceptionally()
boolean	isDone()
Promise<Void>	runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor)
Promise<Void>	runAfterEitherAsync(CompletionStage<?> other, Runnable action, Executor executor)
static Promise<Void>	runAsync(Runnable runnable, Executor executor) Returns a new Promise that is asynchronously resolved by a task running in the given executor after it runs the given action.
protected void	runTask()
static <U> Promise<U>	submit(Callable<U> call, Executor executor) Returns a new Promise that is asynchronously resolved by a task running in the given executor with the value obtained by calling the given Callable.
static <U> Promise<U>	supplyAsync(Supplier<U> supplier, Executor executor) Returns a new Promise that is asynchronously resolved by a task running in the given executor with the value obtained by calling the given Supplier.
Promise<Void>	thenAcceptAsync(Consumer<? super T> action, Executor executor)
<U> Promise<Void>	thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action, Executor executor)
<U> Promise<U>	thenApplyAsync(Function<? super T,? extends U> fn, Executor executor)
<U,V> Promise<V>	thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn, Executor executor)
<U> Promise<U>	thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn, Executor executor)
Promise<T>	thenFilterAsync(Predicate<? super T> predicate, Function<? super T,Throwable> errorSupplier, Executor executor)
Promise<Void>	thenRunAsync(Runnable action, Executor executor)
CompletableFuture<T>	toCompletableFuture()
String	toString()
static <T> Promise<T>	waitFor(CompletionStage<T> stage, Executor executor)
static <T> Promise<T>	waitFor(CompletionStage<T> stage, Executor executor, boolean dependentStage)
Promise<T>	whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)

Methods inherited from class net.tascalate.concurrent.PromiseAdapter

acceptEither, acceptEitherAsync, applyToEither, applyToEitherAsync, exceptionally, exceptionallyAsync, exceptionallyCompose, exceptionallyComposeAsync, getDefaultExecutor, handle, handleAsync, runAfterBoth, runAfterBothAsync, runAfterEither, runAfterEitherAsync, thenAccept, thenAcceptAsync, thenAcceptBoth, thenAcceptBothAsync, thenApply, thenApplyAsync, thenCombine, thenCombineAsync, thenCompose, thenComposeAsync, thenFilter, thenFilter, thenFilterAsync, thenFilterAsync, thenRun, thenRunAsync, whenComplete, whenCompleteAsync

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.tascalate.concurrent.Promise

acceptEither, acceptEitherAsync, acceptEitherAsync, applyToEither, applyToEitherAsync, applyToEitherAsync, as, defaultAsyncOn, delay, delay, delay, delay, dependent, dependent, exceptionally, exceptionallyAsync, exceptionallyCompose, exceptionallyComposeAsync, getNow, getNow, handle, handleAsync, join, onCancel, onTimeout, onTimeout, onTimeout, onTimeout, onTimeout, onTimeout, onTimeout, onTimeout, orTimeout, orTimeout, orTimeout, orTimeout, raw, runAfterBoth, runAfterBothAsync, runAfterBothAsync, runAfterEither, runAfterEitherAsync, runAfterEitherAsync, thenAccept, thenAcceptAsync, thenAcceptAsync, thenAcceptBoth, thenAcceptBothAsync, thenAcceptBothAsync, thenApply, thenApplyAsync, thenCombine, thenCombineAsync, thenCombineAsync, thenCompose, thenComposeAsync, thenFilter, thenFilter, thenFilterAsync, thenFilterAsync, thenFilterAsync, thenFilterAsync, thenRun, thenRunAsync, thenRunAsync, unwrap, whenComplete, whenCompleteAsync

Field Detail

task

protected final RunnableFuture<T> task

Constructor Detail

CompletableTask

protected CompletableTask(Executor executor,
                          Callable<T> callable)

Creates a CompletableTask; for internal use only

Parameters:

executor - a default Executor to run functions passed to async composition methods

callable - a Callable that completes this task

Method Detail

completed

public static <T> Promise<T> completed(T value,
                                       Executor defaultExecutor)

Returns a resolved Promise with specified value; the promise is "bound" to the specified executor. I.e. any function passed to composition methods of Promise (like thenApplyAsync / thenAcceptAsync / whenCompleteAsync etc.) will be executed using this executor unless executor is overridden via explicit composition method parameter. Moreover, any nested composition calls will use same executor, if it’s not redefined via explicit composition method parameter:

CompletableTask
   .complete("Hello!", myExecutor)
   .thenApplyAsync(myMapper)
   .thenApplyAsync(myTransformer)   
   .thenAcceptAsync(myConsumer)
   .thenRunAsync(myAction)
  

All of myMapper, myTransformer, myConsumer, myActtion will be executed using myExecutor

Type Parameters:

T - a type of the successfully executed task result

Parameters:

value - a task result

defaultExecutor - a default Executor to run functions passed to async composition methods (like thenApplyAsync / thenAcceptAsync / whenCompleteAsync etc.)

Returns:

resolved Promise with a value passed; the promise is bound to the specified executor

asyncOn

public static Promise<Void> asyncOn(Executor executor)

Returns a resolved no-value Promise that is "bound" to the specified executor. I.e. any function passed to composition methods of Promise (like thenApplyAsync / thenAcceptAsync / whenCompleteAsync etc.) will be executed using this executor unless executor is overridden via explicit composition method parameter. Moreover, any nested composition calls will use same executor, if it’s not redefined via explicit composition method parameter:

CompletableTask
   .asyncOn(myExecutor)
   .thenApplyAsync(myValueGenerator)
   .thenAcceptAsync(myConsumer)
   .thenRunAsync(myAction)
  

All of myValueGenerator, myConsumer, myActtion will be executed using myExecutor

Parameters:

executor - a default Executor to run functions passed to async composition methods (like thenApplyAsync / thenAcceptAsync / whenCompleteAsync etc.)

Returns:

resolved non-value Promise bound to the specified executor

asyncOn

public static Promise<Void> asyncOn(Executor executor,
                                    boolean enforceDefaultAsync)

Returns a resolved no-value Promise that is "bound" to the specified executor. I.e. any function passed to composition methods of Promise (like thenApplyAsync / thenAcceptAsync / whenCompleteAsync etc.) will be executed using this executor unless executor is overridden via explicit composition method parameter. Moreover, any nested composition calls will use same executor, if it’s not redefined via explicit composition method parameter:

CompletableTask
   .asyncOn(myExecutor)
   .thenApplyAsync(myValueGenerator)
   .thenAcceptAsync(myConsumer)
   .thenRunAsync(myAction)
  

All of myValueGenerator, myConsumer, myActtion will be executed using myExecutor.

Moreover, if enforceDefaultAsync is true, then default executor will be propagated to dependent promises even if corresponding transition was executed on another executor (via composition methods with explicit executor argument).

Parameters:

executor - a default Executor to run functions passed to async composition methods (like thenApplyAsync / thenAcceptAsync / whenCompleteAsync etc.)

enforceDefaultAsync - if true then default executor will be propagated to dependent promises even if corresponding transition was executed on another executor

Returns:

resolved non-value Promise bound to the specified executor

runAsync

public static Promise<Void> runAsync(Runnable runnable,
                                     Executor executor)

Returns a new Promise that is asynchronously resolved by a task running in the given executor after it runs the given action.

Parameters:

runnable - the action to run before resolving the returned Promise

executor - the executor to use for asynchronous execution

Returns:

the new Promise

supplyAsync

public static <U> Promise<U> supplyAsync(Supplier<U> supplier,
                                         Executor executor)

Returns a new Promise that is asynchronously resolved by a task running in the given executor with the value obtained by calling the given Supplier.

Type Parameters:

U - the function's return type

Parameters:

supplier - a function returning the value to be used to resolve the returned Promise

executor - the executor to use for asynchronous execution

Returns:

the new Promise

submit

public static <U> Promise<U> submit(Callable<U> call,
                                    Executor executor)

Returns a new Promise that is asynchronously resolved by a task running in the given executor with the value obtained by calling the given Callable.

Type Parameters:

U - the function's return type

Parameters:

call - a function returning the value to be used to resolve the returned Promise

executor - the executor to use for asynchronous execution

Returns:

the new Promise

waitFor

public static <T> Promise<T> waitFor(CompletionStage<T> stage,
                                     Executor executor)

waitFor

public static <T> Promise<T> waitFor(CompletionStage<T> stage,
                                     Executor executor,
                                     boolean dependentStage)

delay

public static Promise<Duration> delay(long timeout,
                                      TimeUnit unit,
                                      Executor executor)

delay

public static Promise<Duration> delay(Duration duration,
                                      Executor executor)

runTask

protected void runTask()

createCompletionStage

protected <U> net.tascalate.concurrent.AbstractCompletableTask<U> createCompletionStage(Executor executor)

Creates a nested sub-task for a composition method

Parameters:

executor - a default executor for async composition methods of nested sub-task

Returns:

an instance of CompletableSubTask bound to the specified executor

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Specified by:

cancel in interface Future<T>

isCancelled

public boolean isCancelled()

Specified by:

isCancelled in interface Future<T>

isDone

public boolean isDone()

Specified by:

isDone in interface Future<T>

get

public T get()
      throws InterruptedException,
             ExecutionException

Specified by:

get in interface Future<T>

Throws:

InterruptedException

ExecutionException

get

public T get(long timeout,
             TimeUnit unit)
      throws InterruptedException,
             ExecutionException,
             TimeoutException

Specified by:

get in interface Future<T>

Throws:

InterruptedException

ExecutionException

TimeoutException

isCompletedExceptionally

public boolean isCompletedExceptionally()

Specified by:

isCompletedExceptionally in interface Promise<T>

toString

public String toString()

Overrides:

toString in class Object

thenApplyAsync

public <U> Promise<U> thenApplyAsync(Function<? super T,? extends U> fn,
                                     Executor executor)

Specified by:

thenApplyAsync in interface CompletionStage<T>

Specified by:

thenApplyAsync in interface Promise<T>

exceptionallyAsync

public Promise<T> exceptionallyAsync(Function<Throwable,? extends T> fn,
                                     Executor executor)

Specified by:

exceptionallyAsync in interface Promise<T>

handleAsync

public <U> Promise<U> handleAsync(BiFunction<? super T,Throwable,? extends U> fn,
                                  Executor executor)

Specified by:

handleAsync in interface CompletionStage<T>

Specified by:

handleAsync in interface Promise<T>

thenComposeAsync

public <U> Promise<U> thenComposeAsync(Function<? super T,? extends CompletionStage<U>> fn,
                                       Executor executor)

Specified by:

thenComposeAsync in interface CompletionStage<T>

Specified by:

thenComposeAsync in interface Promise<T>

exceptionallyComposeAsync

public Promise<T> exceptionallyComposeAsync(Function<Throwable,? extends CompletionStage<T>> fn,
                                            Executor executor)

Specified by:

exceptionallyComposeAsync in interface Promise<T>

whenCompleteAsync

public Promise<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action,
                                    Executor executor)

Specified by:

whenCompleteAsync in interface CompletionStage<T>

Specified by:

whenCompleteAsync in interface Promise<T>

toCompletableFuture

public CompletableFuture<T> toCompletableFuture()

Specified by:

toCompletableFuture in interface CompletionStage<T>

doApplyToEitherAsync

protected <R,U> Promise<U> doApplyToEitherAsync(CompletionStage<? extends R> first,
                                                CompletionStage<? extends R> second,
                                                Function<? super R,U> fn,
                                                Executor executor)

This method exists just to reconcile generics when called from runAfterEitherAsync(java.util.concurrent.CompletionStage<?>, java.lang.Runnable, java.util.concurrent.Executor) which has unexpected type of parameter "other". The alternative is to ignore compiler warning.

thenAcceptAsync

public Promise<Void> thenAcceptAsync(Consumer<? super T> action,
                                     Executor executor)

thenRunAsync

public Promise<Void> thenRunAsync(Runnable action,
                                  Executor executor)

thenFilterAsync

public Promise<T> thenFilterAsync(Predicate<? super T> predicate,
                                  Function<? super T,Throwable> errorSupplier,
                                  Executor executor)

thenCombineAsync

public <U,V> Promise<V> thenCombineAsync(CompletionStage<? extends U> other,
                                         BiFunction<? super T,? super U,? extends V> fn,
                                         Executor executor)

thenAcceptBothAsync

public <U> Promise<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
                                             BiConsumer<? super T,? super U> action,
                                             Executor executor)

runAfterBothAsync

public Promise<Void> runAfterBothAsync(CompletionStage<?> other,
                                       Runnable action,
                                       Executor executor)

applyToEitherAsync

public <U> Promise<U> applyToEitherAsync(CompletionStage<? extends T> other,
                                         Function<? super T,U> fn,
                                         Executor executor)

acceptEitherAsync

public Promise<Void> acceptEitherAsync(CompletionStage<? extends T> other,
                                       Consumer<? super T> action,
                                       Executor executor)

runAfterEitherAsync

public Promise<Void> runAfterEitherAsync(CompletionStage<?> other,
                                         Runnable action,
                                         Executor executor)

forwardException

protected static <U> U forwardException(Throwable e)

forwardException

protected static <U> Function<Throwable,U> forwardException()

consumerAsFunction

protected static <V,R> Function<V,R> consumerAsFunction(Consumer<? super V> action)