org.apache.flink.runtime.concurrent

Class FutureUtils

java.lang.Object

org.apache.flink.runtime.concurrent.FutureUtils

public class FutureUtils
extends Object

A collection of utilities that expand the usage of CompletableFuture.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	FutureUtils.ConjunctFuture<T> A future that is complete once multiple other futures completed.
static class	FutureUtils.RetryException Exception with which the returned future is completed if the retry(Supplier, int, Executor) operation fails.

Constructor Summary

Constructors

Constructor and Description
FutureUtils()

Method Summary

Modifier and Type	Method and Description
static <T> FutureUtils.ConjunctFuture<Collection<T>>	combineAll(Collection<? extends CompletableFuture<? extends T>> futures) Creates a future that is complete once multiple other futures completed.
static FutureUtils.ConjunctFuture<Void>	completeAll(Collection<? extends CompletableFuture<?>> futuresToComplete) Creates a FutureUtils.ConjunctFuture which is only completed after all given futures have completed.
static <T> CompletableFuture<T>	completedExceptionally(Throwable cause) Returns an exceptionally completed CompletableFuture.
static CompletableFuture<Void>	composeAfterwards(CompletableFuture<?> future, java.util.function.Supplier<CompletableFuture<?>> composedAction) Run the given asynchronous action after the completion of the given future.
static <T> CompletableFuture<T>	orTimeout(CompletableFuture<T> future, long timeout, TimeUnit timeUnit) Times the given future out after the timeout.
static <T> CompletableFuture<T>	retry(java.util.function.Supplier<CompletableFuture<T>> operation, int retries, Executor executor) Retry the given operation the given number of times in case of a failure.
static <T> CompletableFuture<T>	retrySuccessfulWithDelay(java.util.function.Supplier<CompletableFuture<T>> operation, org.apache.flink.api.common.time.Time retryDelay, org.apache.flink.api.common.time.Deadline deadline, java.util.function.Predicate<T> acceptancePredicate, ScheduledExecutor scheduledExecutor) Retry the given operation with the given delay in between successful completions where the result does not match a given predicate.
static <T> CompletableFuture<T>	retryWithDelay(java.util.function.Supplier<CompletableFuture<T>> operation, int retries, org.apache.flink.api.common.time.Time retryDelay, java.util.function.Predicate<Throwable> retryPredicate, ScheduledExecutor scheduledExecutor) Retry the given operation with the given delay in between failures.
static <T> CompletableFuture<T>	retryWithDelay(java.util.function.Supplier<CompletableFuture<T>> operation, int retries, org.apache.flink.api.common.time.Time retryDelay, ScheduledExecutor scheduledExecutor) Retry the given operation with the given delay in between failures.
static CompletableFuture<Void>	runAfterwards(CompletableFuture<?> future, org.apache.flink.util.function.RunnableWithException runnable) Run the given action after the completion of the given future.
static CompletableFuture<Void>	runAfterwardsAsync(CompletableFuture<?> future, org.apache.flink.util.function.RunnableWithException runnable) Run the given action after the completion of the given future.
static CompletableFuture<Void>	runAfterwardsAsync(CompletableFuture<?> future, org.apache.flink.util.function.RunnableWithException runnable, Executor executor) Run the given action after the completion of the given future.
static <T> CompletableFuture<T>	supplyAsync(org.apache.flink.util.function.SupplierWithException<T,?> supplier, Executor executor) Returns a future which is completed with the result of the SupplierWithException.
static scala.concurrent.duration.FiniteDuration	toFiniteDuration(org.apache.flink.api.common.time.Time time) Converts Flink time into a FiniteDuration.
static <T,U extends T> CompletableFuture<T>	toJava(scala.concurrent.Future<U> scalaFuture) Converts a Scala Future to a CompletableFuture.
static org.apache.flink.api.common.time.Time	toTime(scala.concurrent.duration.FiniteDuration finiteDuration) Converts FiniteDuration into Flink time.
static FutureUtils.ConjunctFuture<Void>	waitForAll(Collection<? extends CompletableFuture<?>> futures) Creates a future that is complete once all of the given futures have completed.

Methods inherited from class java.lang.Object

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

Constructor Detail

FutureUtils

public FutureUtils()

Method Detail

retry

public static <T> CompletableFuture<T> retry(java.util.function.Supplier<CompletableFuture<T>> operation,
                                             int retries,
                                             Executor executor)

Retry the given operation the given number of times in case of a failure.

Type Parameters:

T - type of the result

Parameters:

operation - to executed

retries - if the operation failed

executor - to use to run the futures

Returns:

Future containing either the result of the operation or a FutureUtils.RetryException

retryWithDelay

public static <T> CompletableFuture<T> retryWithDelay(java.util.function.Supplier<CompletableFuture<T>> operation,
                                                      int retries,
                                                      org.apache.flink.api.common.time.Time retryDelay,
                                                      java.util.function.Predicate<Throwable> retryPredicate,
                                                      ScheduledExecutor scheduledExecutor)

Retry the given operation with the given delay in between failures.

Type Parameters:

T - type of the result

Parameters:

operation - to retry

retries - number of retries

retryDelay - delay between retries

retryPredicate - Predicate to test whether an exception is retryable

scheduledExecutor - executor to be used for the retry operation

Returns:

Future which retries the given operation a given amount of times and delays the retry in case of failures

retryWithDelay

public static <T> CompletableFuture<T> retryWithDelay(java.util.function.Supplier<CompletableFuture<T>> operation,
                                                      int retries,
                                                      org.apache.flink.api.common.time.Time retryDelay,
                                                      ScheduledExecutor scheduledExecutor)

Retry the given operation with the given delay in between failures.

Type Parameters:

T - type of the result

Parameters:

operation - to retry

retries - number of retries

retryDelay - delay between retries

scheduledExecutor - executor to be used for the retry operation

Returns:

Future which retries the given operation a given amount of times and delays the retry in case of failures

retrySuccessfulWithDelay

public static <T> CompletableFuture<T> retrySuccessfulWithDelay(java.util.function.Supplier<CompletableFuture<T>> operation,
                                                                org.apache.flink.api.common.time.Time retryDelay,
                                                                org.apache.flink.api.common.time.Deadline deadline,
                                                                java.util.function.Predicate<T> acceptancePredicate,
                                                                ScheduledExecutor scheduledExecutor)

Retry the given operation with the given delay in between successful completions where the result does not match a given predicate.

Type Parameters:

T - type of the result

Parameters:

operation - to retry

retryDelay - delay between retries

deadline - A deadline that specifies at what point we should stop retrying

acceptancePredicate - Predicate to test whether the result is acceptable

scheduledExecutor - executor to be used for the retry operation

Returns:

Future which retries the given operation a given amount of times and delays the retry in case the predicate isn't matched

orTimeout

public static <T> CompletableFuture<T> orTimeout(CompletableFuture<T> future,
                                                 long timeout,
                                                 TimeUnit timeUnit)

Times the given future out after the timeout.

Type Parameters:

T - type of the given future

Parameters:

future - to time out

timeout - after which the given future is timed out

timeUnit - time unit of the timeout

Returns:

The timeout enriched future

runAfterwards

public static CompletableFuture<Void> runAfterwards(CompletableFuture<?> future,
                                                    org.apache.flink.util.function.RunnableWithException runnable)

Run the given action after the completion of the given future. The given future can be completed normally or exceptionally. In case of an exceptional completion the, the action's exception will be added to the initial exception.

Parameters:

future - to wait for its completion

runnable - action which is triggered after the future's completion

Returns:

Future which is completed after the action has completed. This future can contain an exception, if an error occurred in the given future or action.

runAfterwardsAsync

public static CompletableFuture<Void> runAfterwardsAsync(CompletableFuture<?> future,
                                                         org.apache.flink.util.function.RunnableWithException runnable)

Run the given action after the completion of the given future. The given future can be completed normally or exceptionally. In case of an exceptional completion the, the action's exception will be added to the initial exception.

Parameters:

future - to wait for its completion

runnable - action which is triggered after the future's completion

Returns:

Future which is completed after the action has completed. This future can contain an exception, if an error occurred in the given future or action.

runAfterwardsAsync

public static CompletableFuture<Void> runAfterwardsAsync(CompletableFuture<?> future,
                                                         org.apache.flink.util.function.RunnableWithException runnable,
                                                         Executor executor)

Run the given action after the completion of the given future. The given future can be completed normally or exceptionally. In case of an exceptional completion the, the action's exception will be added to the initial exception.

Parameters:

future - to wait for its completion

runnable - action which is triggered after the future's completion

executor - to run the given action

Returns:

Future which is completed after the action has completed. This future can contain an exception, if an error occurred in the given future or action.

composeAfterwards

public static CompletableFuture<Void> composeAfterwards(CompletableFuture<?> future,
                                                        java.util.function.Supplier<CompletableFuture<?>> composedAction)

Run the given asynchronous action after the completion of the given future. The given future can be completed normally or exceptionally. In case of an exceptional completion, the asynchronous action's exception will be added to the initial exception.

Parameters:

future - to wait for its completion

composedAction - asynchronous action which is triggered after the future's completion

Returns:

Future which is completed after the asynchronous action has completed. This future can contain an exception if an error occurred in the given future or asynchronous action.

combineAll

public static <T> FutureUtils.ConjunctFuture<Collection<T>> combineAll(Collection<? extends CompletableFuture<? extends T>> futures)

Creates a future that is complete once multiple other futures completed. The future fails (completes exceptionally) once one of the futures in the conjunction fails. Upon successful completion, the future returns the collection of the futures' results.

The ConjunctFuture gives access to how many Futures in the conjunction have already completed successfully, via FutureUtils.ConjunctFuture.getNumFuturesCompleted().

Parameters:

futures - The futures that make up the conjunction. No null entries are allowed.

Returns:

The ConjunctFuture that completes once all given futures are complete (or one fails).

waitForAll

public static FutureUtils.ConjunctFuture<Void> waitForAll(Collection<? extends CompletableFuture<?>> futures)

Creates a future that is complete once all of the given futures have completed. The future fails (completes exceptionally) once one of the given futures fails.

The ConjunctFuture gives access to how many Futures have already completed successfully, via FutureUtils.ConjunctFuture.getNumFuturesCompleted().

Parameters:

futures - The futures to wait on. No null entries are allowed.

Returns:

The WaitingFuture that completes once all given futures are complete (or one fails).

completeAll

public static FutureUtils.ConjunctFuture<Void> completeAll(Collection<? extends CompletableFuture<?>> futuresToComplete)

Creates a FutureUtils.ConjunctFuture which is only completed after all given futures have completed. Unlike waitForAll(Collection), the resulting future won't be completed directly if one of the given futures is completed exceptionally. Instead, all occurring exception will be collected and combined to a single exception. If at least on exception occurs, then the resulting future will be completed exceptionally.

Parameters:

futuresToComplete - futures to complete

Returns:

Future which is completed after all given futures have been completed.

completedExceptionally

public static <T> CompletableFuture<T> completedExceptionally(Throwable cause)

Returns an exceptionally completed CompletableFuture.

Type Parameters:

T - type of the future

Parameters:

cause - to complete the future with

Returns:

An exceptionally completed CompletableFuture

supplyAsync

public static <T> CompletableFuture<T> supplyAsync(org.apache.flink.util.function.SupplierWithException<T,?> supplier,
                                                   Executor executor)

Returns a future which is completed with the result of the SupplierWithException.

Type Parameters:

T - type of the result

Parameters:

supplier - to provide the future's value

executor - to execute the supplier

Returns:

Future which is completed with the value of the supplier

toFiniteDuration

public static scala.concurrent.duration.FiniteDuration toFiniteDuration(org.apache.flink.api.common.time.Time time)

Converts Flink time into a FiniteDuration.

Parameters:

time - to convert into a FiniteDuration

Returns:

FiniteDuration with the length of the given time

toTime

public static org.apache.flink.api.common.time.Time toTime(scala.concurrent.duration.FiniteDuration finiteDuration)

Converts FiniteDuration into Flink time.

Parameters:

finiteDuration - to convert into Flink time

Returns:

Flink time with the length of the given finite duration

toJava

public static <T,U extends T> CompletableFuture<T> toJava(scala.concurrent.Future<U> scalaFuture)

Converts a Scala Future to a CompletableFuture.

Type Parameters:

T - type of the future value

U - type of the original future

Parameters:

scalaFuture - to convert to a Java 8 CompletableFuture

Returns:

Java 8 CompletableFuture