com.google.common.util.concurrent

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>, java.util.concurrent.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.

Nested Class Summary

Nested classes/interfaces inherited from class com.google.common.util.concurrent.ForwardingFuture

ForwardingFuture.SimpleForwardingFuture<V>

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.concurrent.Executor	adapterExecutor
private static java.util.concurrent.Executor	defaultAdapterExecutor
private java.util.concurrent.Future<V>	delegate
private ExecutionList	executionList
private java.util.concurrent.atomic.AtomicBoolean	hasListeners
private static java.util.concurrent.ThreadFactory	threadFactory

Constructor Summary

Constructors

Constructor and Description
ListenableFutureAdapter(java.util.concurrent.Future<V> delegate)
ListenableFutureAdapter(java.util.concurrent.Future<V> delegate, java.util.concurrent.Executor adapterExecutor)

Method Summary

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.
protected java.util.concurrent.Future<V>	delegate() Returns the backing delegate instance that methods are forwarded to.

Methods inherited from class com.google.common.util.concurrent.ForwardingFuture

cancel, get, get, isCancelled, isDone

Methods inherited from class com.google.common.collect.ForwardingObject

toString

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.concurrent.Future

cancel, get, get, isCancelled, isDone

Field Detail

threadFactory

private static final java.util.concurrent.ThreadFactory threadFactory

defaultAdapterExecutor

private static final java.util.concurrent.Executor defaultAdapterExecutor

adapterExecutor

private final java.util.concurrent.Executor adapterExecutor

executionList

private final ExecutionList executionList

hasListeners

private final java.util.concurrent.atomic.AtomicBoolean hasListeners

delegate

private final java.util.concurrent.Future<V> delegate

Constructor Detail

ListenableFutureAdapter

ListenableFutureAdapter(java.util.concurrent.Future<V> delegate)

ListenableFutureAdapter

ListenableFutureAdapter(java.util.concurrent.Future<V> delegate,
                        java.util.concurrent.Executor adapterExecutor)

Method Detail

delegate

protected java.util.concurrent.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(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(). For heavier listeners, directExecutor() carries some caveats. For example, the listener may run on an unpredictable or undesirable thread:

• If this Future is done at the time addListener is called, addListener will execute the listener inline.
• If this Future is not yet done, addListener will schedule the listener to be run by the thread that completes this Future, which may be an internal system thread such as an RPC network thread.

Also note that, regardless of which thread executes the directExecutor() 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