W3cubDocs

/OpenJDK 8

Class CompletableFuture<T>

java.lang.Object
- java.util.concurrent.CompletableFuture<T>

All Implemented Interfaces:: CompletionStage<T>, Future<T>

public class CompletableFuture<T>
extends Object
implements Future<T>, CompletionStage<T>

A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion.

When two or more threads attempt to complete, completeExceptionally, or cancel a CompletableFuture, only one of them succeeds.

In addition to these and related methods for directly manipulating status and results, CompletableFuture implements interface CompletionStage with the following policies:

Actions supplied for dependent completions of non-async methods may be performed by the thread that completes the current CompletableFuture, or by any other caller of a completion method.
All async methods without an explicit Executor argument are performed using the ForkJoinPool.commonPool() (unless it does not support a parallelism level of at least two, in which case, a new Thread is created to run each task). To simplify monitoring, debugging, and tracking, all generated asynchronous tasks are instances of the marker interface CompletableFuture.AsynchronousCompletionTask.
All CompletionStage methods are implemented independently of other public methods, so the behavior of one method is not impacted by overrides of others in subclasses.

CompletableFuture also implements Future with the following policies:

Since (unlike FutureTask) this class has no direct control over the computation that causes it to be completed, cancellation is treated as just another form of exceptional completion. Method cancel has the same effect as completeExceptionally(new CancellationException()). Method isCompletedExceptionally() can be used to determine if a CompletableFuture completed in any exceptional fashion.
In case of exceptional completion with a CompletionException, methods get() and get(long, TimeUnit) throw an ExecutionException with the same cause as held in the corresponding CompletionException. To simplify usage in most contexts, this class also defines methods join() and getNow(T) that instead throw the CompletionException directly in these cases.

Since:: 1.8

Nested Classes

Nested Classes
Modifier and Type	Class and Description
`static interface`	`CompletableFuture.AsynchronousCompletionTask` A marker interface identifying asynchronous tasks produced by `async` methods.

Constructors

CompletableFuture

public CompletableFuture()

Creates a new incomplete CompletableFuture.

Methods

supplyAsync

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)

Returns a new CompletableFuture that is asynchronously completed by a task running in the ForkJoinPool.commonPool() 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 complete the returned CompletableFuture
Returns:: the new CompletableFuture

supplyAsync

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

Returns a new CompletableFuture that is asynchronously completed 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 complete the returned CompletableFuture; executor - the executor to use for asynchronous execution
Returns:: the new CompletableFuture

runAsync

public static CompletableFuture<Void> runAsync(Runnable runnable)

Returns a new CompletableFuture that is asynchronously completed by a task running in the ForkJoinPool.commonPool() after it runs the given action.

Parameters:: runnable - the action to run before completing the returned CompletableFuture
Returns:: the new CompletableFuture

runAsync

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

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

Parameters:: runnable - the action to run before completing the returned CompletableFuture; executor - the executor to use for asynchronous execution
Returns:: the new CompletableFuture

completedFuture

public static <U> CompletableFuture<U> completedFuture(U value)

Returns a new CompletableFuture that is already completed with the given value.

Type Parameters:: U - the type of the value
Parameters:: value - the value
Returns:: the completed CompletableFuture

isDone

public boolean isDone()

Returns true if completed in any fashion: normally, exceptionally, or via cancellation.

Specified by:: isDone in interface Future<T>
Returns:: true if completed

get

public T get()
      throws InterruptedException,
             ExecutionException

Waits if necessary for this future to complete, and then returns its result.

Specified by:: get in interface Future<T>
Returns:: the result value
Throws:: CancellationException - if this future was cancelled; ExecutionException - if this future completed exceptionally; InterruptedException - if the current thread was interrupted while waiting

get

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

Waits if necessary for at most the given time for this future to complete, and then returns its result, if available.

Specified by:: get in interface Future<T>
Parameters:: timeout - the maximum time to wait; unit - the time unit of the timeout argument
Returns:: the result value
Throws:: CancellationException - if this future was cancelled; ExecutionException - if this future completed exceptionally; InterruptedException - if the current thread was interrupted while waiting; TimeoutException - if the wait timed out

join

public T join()

Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally. To better conform with the use of common functional forms, if a computation involved in the completion of this CompletableFuture threw an exception, this method throws an (unchecked) CompletionException with the underlying exception as its cause.

Returns:: the result value
Throws:: CancellationException - if the computation was cancelled; CompletionException - if this future completed exceptionally or a completion computation threw an exception

getNow

public T getNow(T valueIfAbsent)

Returns the result value (or throws any encountered exception) if completed, else returns the given valueIfAbsent.

Parameters:: valueIfAbsent - the value to return if not completed
Returns:: the result value, if completed, else the given valueIfAbsent
Throws:: CancellationException - if the computation was cancelled; CompletionException - if this future completed exceptionally or a completion computation threw an exception

complete

public boolean complete(T value)

If not already completed, sets the value returned by get() and related methods to the given value.

Parameters:: value - the result value
Returns:: true if this invocation caused this CompletableFuture to transition to a completed state, else false

completeExceptionally

public boolean completeExceptionally(Throwable ex)

If not already completed, causes invocations of get() and related methods to throw the given exception.

Parameters:: ex - the exception
Returns:: true if this invocation caused this CompletableFuture to transition to a completed state, else false