AbstractFuture (Apache Hadoop HDFS 3.5.0 API)
Description: declaration: package: org.apache.hadoop.hdfs.server.datanode.checker, class: AbstractFuture

Package org.apache.hadoop.hdfs.server.datanode.checker

# Class AbstractFuture<V>

java.lang.Object
org.apache.hadoop.hdfs.server.datanode.checker.AbstractFuture<V>

All Implemented Interfaces:
  `Future<V>`, `org.apache.hadoop.thirdparty.com.google.common.util.concurrent.ListenableFuture<V>`

@GwtCompatible(emulated=true) public abstract class AbstractFuture<V> extends Object implements org.apache.hadoop.thirdparty.com.google.common.util.concurrent.ListenableFuture<V>
An abstract implementation of `ListenableFuture`, intended for advanced users only. More common ways to create a `ListenableFuture` include instantiating a `SettableFuture`, submitting a task to a `ListeningExecutorService`, and deriving a `Future` from an existing one, typically using methods like `(ListenableFuture, org.apache.hadoop.thirdparty.com.google.common.base.Function) Futures.transform` and its overloaded versions.

This class implements all methods in `ListenableFuture`. Subclasses should provide a way to set the result of the computation through the protected methods `set(Object)`, `setFuture(ListenableFuture)` and `setException(Throwable)`. Subclasses may also override `interruptTask()`, which will be invoked automatically if a call to `cancel(true)` succeeds in canceling the future. Subclasses should rarely override other methods.

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `AbstractFuture()`
  Constructor for use by subclasses.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `addListener(Runnable listener, Executor executor)`
  `protected void`
  `afterDone()`
  Callback method that is called exactly once after the future is completed.
  `boolean`
  `cancel(boolean mayInterruptIfRunning)`
  `static Executor`
  `directExecutor()`
  Returns an `Executor` that runs each task in the thread that invokes `execute`, as in `ThreadPoolExecutor.CallerRunsPolicy`.
  `V`
  `get()`
  `V`
  `get(long timeout, TimeUnit unit)`
  `static <V> V`
  `getDone(Future<V> future)`
  `protected void`
  `interruptTask()`
  Subclasses can override this method to implement interruption of the future's computation.
  `boolean`
  `isCancelled()`
  `boolean`
  `isDone()`
  `protected boolean`
  `set(V value)`
  Sets the result of this `Future` unless this `Future` has already been cancelled or set (including set asynchronously).
  `protected boolean`
  `setException(Throwable throwable)`
  Sets the failed result of this `Future` unless this `Future` has already been cancelled or set (including set asynchronously).
  `protected boolean`
  `setFuture(org.apache.hadoop.thirdparty.com.google.common.util.concurrent.ListenableFuture<? extends V> future)`
  Sets the result of this `Future` to match the supplied input `Future` once the supplied `Future` is done, unless this `Future` has already been cancelled or set (including "set asynchronously," defined below).
  `protected final boolean`
  `wasInterrupted()`
  Returns true if this future was cancelled with `mayInterruptIfRunning` set to `true`.

  ### Methods inherited from class java.lang.Object

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

- ## Constructor Details

  - ### AbstractFuture

    protected AbstractFuture()
    Constructor for use by subclasses.

- ## Method Details

  - ### get

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

    The default `AbstractFuture` implementation throws `InterruptedException` if the current thread is interrupted before or during the call, even if the value is already available.

    Specified by:
      `get` in interface `Future<V>`
    Throws:
      `InterruptedException` - if the current thread was interrupted before or during the call (optional but recommended).
      `CancellationException`
      `TimeoutException`
      `ExecutionException`

  - ### get

    public V get() throws InterruptedException, ExecutionException

    The default `AbstractFuture` implementation throws `InterruptedException` if the current thread is interrupted before or during the call, even if the value is already available.

    Specified by:
      `get` in interface `Future<V>`
    Throws:
      `InterruptedException` - if the current thread was interrupted before or during the call (optional but recommended).
      `CancellationException`
      `ExecutionException`

  - ### isDone

    public boolean isDone()
    Specified by:
      `isDone` in interface `Future<V>`

  - ### isCancelled

    public boolean isCancelled()
    Specified by:
      `isCancelled` in interface `Future<V>`

  - ### cancel

    public boolean cancel(boolean mayInterruptIfRunning)

    If a cancellation attempt succeeds on a `Future` that had previously been set asynchronously, then the cancellation will also be propagated to the delegate `Future` that was supplied in the `setFuture` call.

    Specified by:
      `cancel` in interface `Future<V>`

  - ### interruptTask

    protected void interruptTask()
    Subclasses can override this method to implement interruption of the future's computation. The method is invoked automatically by a successful call to `cancel(true)`.

    The default implementation does nothing.

    Since:
      10.0

  - ### wasInterrupted

    protected final boolean wasInterrupted()
    Returns true if this future was cancelled with `mayInterruptIfRunning` set to `true`.
    Since:
      14.0

  - ### addListener

    public void addListener(Runnable listener, Executor executor)
    Specified by:
      `addListener` in interface `org.apache.hadoop.thirdparty.com.google.common.util.concurrent.ListenableFuture<V>`
    Since:
      10.0

  - ### set

    protected boolean set(@Nullable V value)
    Sets the result of this `Future` unless this `Future` has already been cancelled or set (including set asynchronously). When a call to this method returns, the `Future` is guaranteed to be done only if the call was accepted (in which case it returns `true`). If it returns `false`, the `Future` may have previously been set asynchronously, in which case its result may not be known yet. That result, though not yet known, cannot be overridden by a call to a `set*` method, only by a call to `cancel(boolean)`.
    Parameters:
      `value` - the value to be used as the result
    Returns:
      true if the attempt was accepted, completing the `Future`

  - ### setException

    protected boolean setException(Throwable throwable)
    Sets the failed result of this `Future` unless this `Future` has already been cancelled or set (including set asynchronously). When a call to this method returns, the `Future` is guaranteed to be done only if the call was accepted (in which case it returns `true`). If it returns `false`, the `Future` may have previously been set asynchronously, in which case its result may not be known yet. That result, though not yet known, cannot be overridden by a call to a `set*` method, only by a call to `cancel(boolean)`.
    Parameters:
      `throwable` - the exception to be used as the failed result
    Returns:
      true if the attempt was accepted, completing the `Future`

  - ### setFuture

    @Beta protected boolean setFuture(org.apache.hadoop.thirdparty.com.google.common.util.concurrent.ListenableFuture<? extends V> future)
    Sets the result of this `Future` to match the supplied input `Future` once the supplied `Future` is done, unless this `Future` has already been cancelled or set (including "set asynchronously," defined below).

    If the supplied future is done when this method is called and the call is accepted, then this future is guaranteed to have been completed with the supplied future by the time this method returns. If the supplied future is not done and the call is accepted, then the future will be set asynchronously. Note that such a result, though not yet known, cannot be overridden by a call to a `set*` method, only by a call to `cancel(boolean)`.

    If the call `setFuture(delegate)` is accepted and this `Future` is later cancelled, cancellation will be propagated to `delegate`. Additionally, any call to `setFuture` after any cancellation will propagate cancellation to the supplied `Future`.

    Parameters:
      `future` - the future to delegate to
    Returns:
      true if the attempt was accepted, indicating that the `Future` was not previously cancelled or set.
    Since:
      19.0

  - ### getDone

    public static <V> V getDone(Future<V> future) throws ExecutionException
    Throws:
      `ExecutionException`

  - ### afterDone

    @Beta protected void afterDone()
    Callback method that is called exactly once after the future is completed.

    If `interruptTask()` is also run during completion, `afterDone()` runs after it.

    The default implementation of this method in `AbstractFuture` does nothing. This is intended for very lightweight cleanup work, for example, timing statistics or clearing fields. If your task does anything heavier consider, just using a listener with an executor.

    Since:
      20.0

  - ### directExecutor

    public static Executor directExecutor()
    Returns an `Executor` that runs each task in the thread that invokes `execute`, as in `ThreadPoolExecutor.CallerRunsPolicy`.

    This instance is equivalent to:

           final class DirectExecutor implements Executor {
             public void execute(Runnable r) {
               r.run();
             }
           }