Package com.google.common.util.concurrent

Class AbstractFuture<V>

  • All Implemented Interfaces:
    ListenableFuture<V>, java.util.concurrent.Future<V>
    Direct Known Subclasses:
    SettableFuture
    public abstract class AbstractFuture<V>
extends java.lang.Object
implements ListenableFuture<V>
    An abstract implementation of the ListenableFuture interface. This class is preferable to FutureTask for two reasons: It implements ListenableFuture, and it does not implement Runnable. (If you want a Runnable implementation of ListenableFuture, create a ListenableFutureTask, or submit your tasks to a ListeningExecutorService.)

    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) and setException(Throwable). Subclasses may also override interruptTask(), which will be invoked automatically if a call to cancel(true) succeeds in canceling the future.

    AbstractFuture uses an AbstractQueuedSynchronizer to deal with concurrency issues and guarantee thread safety.

    The state changing methods all return a boolean indicating success or failure in changing the future's state. Valid states are running, completed, failed, or cancelled.

    This class uses an ExecutionList to guarantee that all registered listeners will be executed, either when the future finishes or, for listeners that are added after the future completes, immediately. Runnable-Executor pairs are stored in the execution list but are not necessarily executed in the order in which they were added. (If a listener is added after the Future is complete, it will be executed immediately, even if earlier listeners have not been executed. Additionally, executors need not guarantee FIFO execution, or different listeners may run in different executors.)

    Since:
    1.0

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void addListener​(java.lang.Runnable listener, java.util.concurrent.Executor exec)
      Registers a listener to be run on the given executor.
      boolean cancel​(boolean mayInterruptIfRunning)  
      V get()
      V get​(long timeout, java.util.concurrent.TimeUnit unit)
      boolean isCancelled()  
      boolean isDone()  

      • Methods inherited from class java.lang.Object

        equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Method Detail

      • get

        public V get​(long timeout,
             java.util.concurrent.TimeUnit unit)
      throws java.lang.InterruptedException,
             java.util.concurrent.TimeoutException,
             java.util.concurrent.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 java.util.concurrent.Future<V>
        Throws:
        java.lang.InterruptedException - if the current thread was interrupted before or during the call (optional but recommended).
        java.util.concurrent.CancellationException
        java.util.concurrent.TimeoutException
        java.util.concurrent.ExecutionException

      • get

        public V get()
      throws java.lang.InterruptedException,
             java.util.concurrent.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 java.util.concurrent.Future<V>
        Throws:
        java.lang.InterruptedException - if the current thread was interrupted before or during the call (optional but recommended).
        java.util.concurrent.CancellationException
        java.util.concurrent.ExecutionException

      • isDone

        public boolean isDone()
        Specified by:
        isDone in interface java.util.concurrent.Future<V>

      • isCancelled

        public boolean isCancelled()
        Specified by:
        isCancelled in interface java.util.concurrent.Future<V>

      • cancel

        public boolean cancel​(boolean mayInterruptIfRunning)
        Specified by:
        cancel in interface java.util.concurrent.Future<V>

      • addListener

        public void addListener​(java.lang.Runnable listener,
                        java.util.concurrent.Executor exec)
        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 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 sameThreadExecutor() 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
        Since:
        10.0