Package de.linusdev.lutils.async

Interface Future<R,S>

Type Parameters:

R - the result type

S - the secondary result type. usually contains information about the task's execution process.

All Superinterfaces:

HasAsyncManager

All Known Implementing Classes:

AbstractFuture, CompletableFuture, ConditionedFuture, ExecutableFuture, QueueableFuture

public interface Future<R,S>
extends HasAsyncManager

A Future represents a Task that will be executed in the future and whose result or error will be retrieved.

Before the Task bound to this future will supposedly start execution:

before execution listener will be called before and can still cancel() this future.

Once the future has finished (if it wasn't canceled):
Meaning that the Task has finished execution . The following actions will follow in the following order

1. all Threads waiting on get() will be notified
2. All result listeners (see, see, see) will be called in the order they have been added to this Future.

If the future was canceled:

• All Threads waiting on get() will be resumed and a CancellationException will be thrown.
• The Task will not be executed.
• beforeExecution(Consumer) listener will not be called.

If any then listener (see, see, see) is set after the result has already been retrieved:

The listener will be called immediately in the setting thread

Method Summary

Modifier and Type	Method	Description
@NotNull Future<R,S>	beforeExecution(@NotNull Consumer<Future<R,S>> consumer)	Given consumer will be called before the Future will be executed.
@NotNull Future<R,S>	cancel()	Cancels this future, if it is not already executing.
@NotNull ComputationResult<R,S>	get()	Waits the current Thread until this Future has been executed.
default R	getResult()	Waits the current Thread until this Future has been executed.
boolean	hasStarted()
boolean	isCanceled()
boolean	isDone()
default @NotNull Future<R,S>	then(@NotNull ResultAndErrorConsumer<R,S> consumer)	Given consumer will be called after Future's execution has finished and result or error is ready.
@NotNull Future<R,S>	then(@NotNull ResultConsumer<R,S> consumer)	Given consumer will be called after Future's execution has finished and result or error is ready.
default @NotNull Future<R,S>	then(@NotNull SingleResultConsumer<R,S> consumer)	Given consumer will be called after Future's execution has finished and result or error is ready.

Methods inherited from interface de.linusdev.lutils.async.manager.HasAsyncManager

getAsyncManager

Method Details

cancel

@NotNull
@NotNull Future<R,S> cancel()

Cancels this future, if it is not already executing.

Returns:

the canceled Future

isCanceled

boolean isCanceled()

Returns:

true if this Future is canceled.

hasStarted

boolean hasStarted()

Returns:

true if this Future has started its execution.

isDone

boolean isDone()

Returns:

true if this Future is done (execution finished and result or error is ready).

beforeExecution

@NotNull
@NotNull Future<R,S> beforeExecution(@NotNull
 @NotNull Consumer<Future<R,S>> consumer)

Given consumer will be called before the Future will be executed. The Future can still be canceled.

Parameters:

consumer - Consumer that will be called before execution

Returns:

the Future itself.

then

@NotNull
@NotNull Future<R,S> then(@NotNull
 @NotNull ResultConsumer<R,S> consumer)

Given consumer will be called after Future's execution has finished and result or error is ready.

Parameters:

consumer - ResultConsumer

Returns:

the Future itself.

then

@NotNull
default @NotNull Future<R,S> then(@NotNull
 @NotNull ResultAndErrorConsumer<R,S> consumer)

Given consumer will be called after Future's execution has finished and result or error is ready.

Parameters:

consumer - ResultAndErrorConsumer

Returns:

the Future itself.

then

@NotNull
default @NotNull Future<R,S> then(@NotNull
 @NotNull SingleResultConsumer<R,S> consumer)

Given consumer will be called after Future's execution has finished and result or error is ready.

Parameters:

consumer - SingleResultConsumer

Returns:

the Future itself.

get

@Blocking
@NotNull
@NotNull ComputationResult<R,S> get()
                             throws InterruptedException,
CancellationException

Waits the current Thread until this Future has been executed. If execution has already finished, this method will return immediately.

Returns:

ComputationResult containing the result, secondary result and a potential error.

Throws:

InterruptedException - if interrupted while waiting

CancellationException - if the Future has been canceled.

getResult

@Blocking
@NotNull
default R getResult()
             throws InterruptedException,
ErrorException

Waits the current Thread until this Future has been executed. If execution has already finished, this method will return immediately.

Returns:

Future result

Throws:

InterruptedException - if interrupted while waiting

ErrorException - if the Future returned with an error.