## 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>, Runnable, Future<V>, RunnableFuture<V>

    public final class ListenableFutureTask<V>

extends 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
Author:
  Sven Mawson

Method Summary
`void` `addListener(Runnable listener, Executor exec)` Registers a listener to be run on the given executor.

`static

`<V> ListenableFutureTask<V>`

`

`create(Callable<V> callable)`
Creates a `ListenableFutureTask` that will upon running, execute the given `Callable`.

`static

`<V> ListenableFutureTask<V>`

`

`create(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(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(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(Runnable listener,
                            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 inline execution) will be caught and logged.

  Note: For fast, lightweight listeners that would be safe to execute in any thread, consider `MoreExecutors.sameThreadExecutor()`. For heavier listeners, `sameThreadExecutor()` carries some caveats. For example, the listener may run on an unpredictable or undesirable thread:

  - If the input `Future` is done at the time `addListener` is called, `addListener` will execute the listener inline.
  - If the input `Future` is not yet done, `addListener` will schedule the listener to be run by the thread that completes the input `Future`, which may be an internal system thread such as an RPC network thread.
  Also note that, regardless of which thread executes the listener, all other registered but unexecuted listeners are prevented from running during its execution, even if those listeners are to run in other executors.

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

  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 `FutureTask<V>`

Copyright © 2010-2012. All Rights Reserved.