1/*
2 * Written by Doug Lea with assistance from members of JCP JSR-166
3 * Expert Group and released to the public domain, as explained at
4 * http://creativecommons.org/publicdomain/zero/1.0/
5 */
6
7package java.util.concurrent;
8
9/**
10 * A {@code Future} represents the result of an asynchronous
11 * computation.  Methods are provided to check if the computation is
12 * complete, to wait for its completion, and to retrieve the result of
13 * the computation.  The result can only be retrieved using method
14 * {@code get} when the computation has completed, blocking if
15 * necessary until it is ready.  Cancellation is performed by the
16 * {@code cancel} method.  Additional methods are provided to
17 * determine if the task completed normally or was cancelled. Once a
18 * computation has completed, the computation cannot be cancelled.
19 * If you would like to use a {@code Future} for the sake
20 * of cancellability but not provide a usable result, you can
21 * declare types of the form {@code Future<?>} and
22 * return {@code null} as a result of the underlying task.
23 *
24 * <p>
25 * <b>Sample Usage</b> (Note that the following classes are all
26 * made-up.)
27 *
28 * <pre> {@code
29 * interface ArchiveSearcher { String search(String target); }
30 * class App {
31 *   ExecutorService executor = ...
32 *   ArchiveSearcher searcher = ...
33 *   void showSearch(final String target)
34 *       throws InterruptedException {
35 *     Future<String> future
36 *       = executor.submit(new Callable<String>() {
37 *         public String call() {
38 *             return searcher.search(target);
39 *         }});
40 *     displayOtherThings(); // do other things while searching
41 *     try {
42 *       displayText(future.get()); // use future
43 *     } catch (ExecutionException ex) { cleanup(); return; }
44 *   }
45 * }}</pre>
46 *
47 * The {@link FutureTask} class is an implementation of {@code Future} that
48 * implements {@code Runnable}, and so may be executed by an {@code Executor}.
49 * For example, the above construction with {@code submit} could be replaced by:
50 * <pre> {@code
51 * FutureTask<String> future =
52 *   new FutureTask<>(new Callable<String>() {
53 *     public String call() {
54 *       return searcher.search(target);
55 *   }});
56 * executor.execute(future);}</pre>
57 *
58 * <p>Memory consistency effects: Actions taken by the asynchronous computation
59 * <a href="package-summary.html#MemoryVisibility"> <i>happen-before</i></a>
60 * actions following the corresponding {@code Future.get()} in another thread.
61 *
62 * @see FutureTask
63 * @see Executor
64 * @since 1.5
65 * @author Doug Lea
66 * @param <V> The result type returned by this Future's {@code get} method
67 */
68public interface Future<V> {
69
70    /**
71     * Attempts to cancel execution of this task.  This attempt will
72     * fail if the task has already completed, has already been cancelled,
73     * or could not be cancelled for some other reason. If successful,
74     * and this task has not started when {@code cancel} is called,
75     * this task should never run.  If the task has already started,
76     * then the {@code mayInterruptIfRunning} parameter determines
77     * whether the thread executing this task should be interrupted in
78     * an attempt to stop the task.
79     *
80     * <p>After this method returns, subsequent calls to {@link #isDone} will
81     * always return {@code true}.  Subsequent calls to {@link #isCancelled}
82     * will always return {@code true} if this method returned {@code true}.
83     *
84     * @param mayInterruptIfRunning {@code true} if the thread executing this
85     * task should be interrupted; otherwise, in-progress tasks are allowed
86     * to complete
87     * @return {@code false} if the task could not be cancelled,
88     * typically because it has already completed normally;
89     * {@code true} otherwise
90     */
91    boolean cancel(boolean mayInterruptIfRunning);
92
93    /**
94     * Returns {@code true} if this task was cancelled before it completed
95     * normally.
96     *
97     * @return {@code true} if this task was cancelled before it completed
98     */
99    boolean isCancelled();
100
101    /**
102     * Returns {@code true} if this task completed.
103     *
104     * Completion may be due to normal termination, an exception, or
105     * cancellation -- in all of these cases, this method will return
106     * {@code true}.
107     *
108     * @return {@code true} if this task completed
109     */
110    boolean isDone();
111
112    /**
113     * Waits if necessary for the computation to complete, and then
114     * retrieves its result.
115     *
116     * @return the computed result
117     * @throws CancellationException if the computation was cancelled
118     * @throws ExecutionException if the computation threw an
119     * exception
120     * @throws InterruptedException if the current thread was interrupted
121     * while waiting
122     */
123    V get() throws InterruptedException, ExecutionException;
124
125    /**
126     * Waits if necessary for at most the given time for the computation
127     * to complete, and then retrieves its result, if available.
128     *
129     * @param timeout the maximum time to wait
130     * @param unit the time unit of the timeout argument
131     * @return the computed result
132     * @throws CancellationException if the computation was cancelled
133     * @throws ExecutionException if the computation threw an
134     * exception
135     * @throws InterruptedException if the current thread was interrupted
136     * while waiting
137     * @throws TimeoutException if the wait timed out
138     */
139    V get(long timeout, TimeUnit unit)
140        throws InterruptedException, ExecutionException, TimeoutException;
141}
142