001    /*
002     * Copyright (C) 2007 The Guava Authors
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     * http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package com.google.common.util.concurrent;
018    
019    import java.util.concurrent.Executor;
020    import java.util.concurrent.ExecutorService;
021    import java.util.concurrent.Future;
022    import java.util.concurrent.FutureTask;
023    import java.util.concurrent.RejectedExecutionException;
024    
025    /**
026     * A {@link Future} that accepts completion listeners.  Each listener has an
027     * associated executor, and it is invoked using this executor once the future's
028     * computation is {@linkplain Future#isDone() complete}.  If the computation has
029     * already completed when the listener is added, the listener will execute
030     * immediately.
031     *
032     * <h3>Purpose</h3>
033     *
034     * Most commonly, {@code ListenableFuture} is used as an input to another
035     * derived {@code Future}, as in {@link Futures#allAsList(Iterable)
036     * Futures.allAsList}. Many such methods are impossible to implement efficiently
037     * without listener support.
038     *
039     * <p>It is possible to call {@link #addListener addListener} directly, but this
040     * is uncommon because the {@code Runnable} interface does not provide direct
041     * access to the {@code Future} result. (Users who want such access may prefer
042     * {@link Futures#addCallback Futures.addCallback}.) Still, direct {@code
043     * addListener} calls are occasionally useful:<pre>   {@code
044     *   final String name = ...;
045     *   inFlight.add(name);
046     *   ListenableFuture<Result> future = service.query(name);
047     *   future.addListener(new Runnable() {
048     *     public void run() {
049     *       processedCount.incrementAndGet();
050     *       inFlight.remove(name);
051     *       lastProcessed.set(name);
052     *       logger.info("Done with {0}", name);
053     *     }
054     *   }, executor);}</pre>
055     *
056     * <h3>How to get an instance</h3>
057     *
058     * Developers are encouraged to return {@code ListenableFuture} from their
059     * methods so that users can take advantages of the utilities built atop the
060     * class. The way that they will create {@code ListenableFuture} instances
061     * depends on how they currently create {@code Future} instances:
062     * <ul>
063     * <li>If they are returned from an {@code ExecutorService}, convert that
064     * service to a {@link ListeningExecutorService}, usually by calling {@link
065     * MoreExecutors#listeningDecorator(ExecutorService)
066     * MoreExecutors.listeningDecorator}. (Custom executors may find it more
067     * convenient to use {@link ListenableFutureTask} directly.)
068     * <li>If they are manually filled in by a call to {@link FutureTask#set} or a
069     * similar method, create a {@link SettableFuture} instead. (Users with more
070     * complex needs may prefer {@link AbstractFuture}.)
071     * </ul>
072     *
073     * Occasionally, an API will return a plain {@code Future} and it will be
074     * impossible to change the return type. For this case, we provide a more
075     * expensive workaround in {@code JdkFutureAdapters}. However, when possible, it
076     * is more efficient and reliable to create a {@code ListenableFuture} directly.
077     *
078     * @author Sven Mawson
079     * @author Nishant Thakkar
080     * @since 1.0
081     */
082    public interface ListenableFuture<V> extends Future<V> {
083      /**
084       * Registers a listener to be {@linkplain Executor#execute(Runnable) run} on
085       * the given executor.  The listener will run when the {@code Future}'s
086       * computation is {@linkplain Future#isDone() complete} or, if the computation
087       * is already complete, immediately.
088       *
089       * <p>There is no guaranteed ordering of execution of listeners, but any
090       * listener added through this method is guaranteed to be called once the
091       * computation is complete.
092       *
093       * <p>Exceptions thrown by a listener will be propagated up to the executor.
094       * Any exception thrown during {@code Executor.execute} (e.g., a {@code
095       * RejectedExecutionException} or an exception thrown by {@linkplain
096       * MoreExecutors#sameThreadExecutor inline execution}) will be caught and
097       * logged.
098       *
099       * <p>Note: For fast, lightweight listeners that would be safe to execute in
100       * any thread, consider {@link MoreExecutors#sameThreadExecutor}. For heavier
101       * listeners, {@code sameThreadExecutor()} carries some caveats: First, the
102       * thread that the listener runs in depends on whether the {@code Future} is
103       * done at the time it is added and on whether it is ever canclled. In
104       * particular, listeners may run in the thread that calls {@code addListener}
105       * or the thread that calls {@code cancel}. Second, listeners may run in an
106       * internal thread of the system responsible for the input {@code Future},
107       * such as an RPC network thread. Finally, during the execution of a {@code
108       * sameThreadExecutor()} listener, all other registered but unexecuted
109       * listeners are prevented from running, even if those listeners are to run
110       * in other executors.
111       *
112       * <p>This is the most general listener interface.
113       * For common operations performed using listeners,
114       * see {@link com.google.common.util.concurrent.Futures}
115       *
116       * @param listener the listener to run when the computation is complete
117       * @param executor the executor to run the listener in
118       * @throws NullPointerException if the executor or listener was null
119       * @throws RejectedExecutionException if we tried to execute the listener
120       *         immediately but the executor rejected it.
121       */
122      void addListener(Runnable listener, Executor executor);
123    }