ListenableFutureTask
Date: 2016-05-24

com.google.common.util.concurrent

## Class ListenableFutureTask<V>

- java.lang.Object
- - java.util.concurrent.FutureTask<V>
  - - com.google.common.util.concurrent.ListenableFutureTask<V>

- All Implemented Interfaces:
    ListenableFuture<V>, java.lang.Runnable, java.util.concurrent.Future<V>, java.util.concurrent.RunnableFuture<V>

      public class ListenableFutureTask<V>
      extends java.util.concurrent.FutureTask<V>
      implements ListenableFuture<V>

  A `FutureTask` that also implements the `ListenableFuture` interface. Unlike `FutureTask`, `ListenableFutureTask` does not provide an overrideable `done()` method. For similar functionality, call `addListener(java.lang.Runnable, java.util.concurrent.Executor)`.

  Since:
    1.0

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addListener(java.lang.Runnable listener, java.util.concurrent.Executor exec)` Registers a listener to be run on the given executor.
    `static <V> ListenableFutureTask<V>` | `create(java.util.concurrent.Callable<V> callable)` Creates a `ListenableFutureTask` that will upon running, execute the given `Callable`.
    `static <V> ListenableFutureTask<V>` | `create(java.lang.Runnable runnable, V result)` Creates a `ListenableFutureTask` that will upon running, execute the given `Runnable`, and arrange that `get` will return the given result on successful completion.
    `protected void` | `done()` Internal implementation detail used to invoke the listeners.

    - ### Methods inherited from class java.util.concurrent.FutureTask

      `cancel, get, get, isCancelled, isDone, run, runAndReset, set, setException`

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

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

    - ### Methods inherited from interface java.util.concurrent.Future

      `cancel, get, get, isCancelled, isDone`

- - ### Method Detail

    - #### create

          public static <V> ListenableFutureTask<V> create(java.util.concurrent.Callable<V> callable)

      Creates a `ListenableFutureTask` that will upon running, execute the given `Callable`.
      Parameters:
        `callable` - the callable task
      Since:
        10.0

    - #### create

          public static <V> ListenableFutureTask<V> create(java.lang.Runnable runnable,
                                           @Nullable
                                           V result)

      Creates a `ListenableFutureTask` that will upon running, execute the given `Runnable`, and arrange that `get` will return the given result on successful completion.
      Parameters:
        `runnable` - the runnable task
        `result` - the result to return on successful completion. If you don't need a particular result, consider using constructions of the form: `ListenableFuture<?> f = ListenableFutureTask.create(runnable, null)`
      Since:
        10.0

    - #### addListener

          public void addListener(java.lang.Runnable listener,
                         java.util.concurrent.Executor exec)

      Description copied from interface: `ListenableFuture`
      Registers a listener to be run on the given executor. The listener will run when the `Future`'s computation is complete or, if the computation is already complete, immediately.

      There is no guaranteed ordering of execution of listeners, but any listener added through this method is guaranteed to be called once the computation is complete.

      Exceptions thrown by a listener will be propagated up to the executor. Any exception thrown during `Executor.execute` (e.g., a `RejectedExecutionException` or an exception thrown by direct execution) will be caught and logged.

      Note: For fast, lightweight listeners that would be safe to execute in any thread, consider `MoreExecutors.directExecutor()`. Otherwise, avoid it. Heavyweight `directExecutor` listeners can cause problems, and these problems can be difficult to reproduce because they depend on timing. For example:

      - The listener may be executed by the caller of `addListener`. That caller may be a UI thread or other latency-sensitive thread. This can harm UI responsiveness.
      - The listener may be executed by the thread that completes this `Future`. That thread may be an internal system thread such as an RPC network thread. Blocking that thread may stall progress of the whole system. It may even cause a deadlock.
      - The listener may delay other listeners, even listeners that are not themselves `directExecutor` listeners.

      This is the most general listener interface. For common operations performed using listeners, see `Futures`. For a simplified but general listener interface, see `addCallback()`.

      Memory consistency effects: Actions in a thread prior to adding a listener happen-before its execution begins, perhaps in another thread.

      Specified by:
        `addListener` in interface `ListenableFuture<V>`
      Parameters:
        `listener` - the listener to run when the computation is complete
        `exec` - the executor to run the listener in

    - #### done

          protected void done()

      Internal implementation detail used to invoke the listeners.
      Overrides:
        `done` in class `java.util.concurrent.FutureTask<V>`