Class JdkFutureAdapters.ListenableFutureAdapter<V>

java.lang.Object
com.google.common.collect.ForwardingObject
com.google.common.util.concurrent.ForwardingFuture<V>
com.google.common.util.concurrent.JdkFutureAdapters.ListenableFutureAdapter<V>
All Implemented Interfaces:
ListenableFuture<V>, Future<V>
Enclosing class:
JdkFutureAdapters

private static class JdkFutureAdapters.ListenableFutureAdapter<V> extends ForwardingFuture<V> implements ListenableFuture<V>
An adapter to turn a Future into a ListenableFuture. This will wait on the future to finish, and when it completes, run the listeners. This implementation will wait on the source future indefinitely, so if the source future never completes, the adapter will never complete either.

If the delegate future is interrupted or throws an unexpected unchecked exception, the listeners will not be invoked.

  • Field Details

    • threadFactory

      private static final ThreadFactory threadFactory
    • defaultAdapterExecutor

      private static final Executor defaultAdapterExecutor
    • adapterExecutor

      private final Executor adapterExecutor
    • executionList

      private final ExecutionList executionList
    • hasListeners

      private final AtomicBoolean hasListeners
    • delegate

      private final Future<V> delegate
  • Constructor Details

    • ListenableFutureAdapter

      ListenableFutureAdapter(Future<V> delegate)
    • ListenableFutureAdapter

      ListenableFutureAdapter(Future<V> delegate, Executor adapterExecutor)
  • Method Details

    • delegate

      protected Future<V> delegate()
      Description copied from class: ForwardingObject
      Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as ForwardingSet.delegate(). Concrete subclasses override this method to supply the instance being decorated.
      Specified by:
      delegate in class ForwardingFuture<V>
    • 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 direct execution) will be caught and logged.

      Note: If your listener is lightweight -- and will not cause stack overflow by completing more futures or adding more directExecutor() listeners inline -- consider MoreExecutors.directExecutor(). Otherwise, avoid it: See the warnings on the docs for directExecutor.

      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.

      Guava implementations of ListenableFuture promptly release references to listeners after executing them.

      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