Future接口（源码解读）

旧城等待， 2024-04-17 05:40 77阅读 0赞

Future接口源码解读：

此接口有5个方法

**boolean cancel(boolean mayInterruptIfRunning);**

> 此方法目的是想让其实现类实现以下功能：
> 
> 尝试取消一个任务的执行。
> 
> 当任务已经执行结束后，或已经被取消执行后，或者因为其他原因不能被取消任务执行时，返回false。
> 
> 当cancel调用时，如果任务还未开始执行，那么任务将会直接取消并永远不会执行，返回true。
> 
> 参数 **boolean mayInterruptIfRunning设为true时，正在执行的任务将会被中断。**
> 
> 参数 **boolean mayInterruptIfRunning设为false时，正在执行的任务将会被允许执行完成。**

**boolean isCancelled();**

> 如果方法已经被结束了在正常执行完成之前，放回true。

** boolean isDone();**

> 如果一个任务已经被执行完成，则返回true。
> 
> 这种完成可以是正常的执行结束，或抛出异常结束，或被取消结束。

** V get() throws InterruptedException, ExecutionException;**

> 此方法用于一个可以放回结果的任务，去接收此任务的返回结果，get方法在调用并获取到结果之前会等待。
> 
> 当任务被取消时，调用get会抛出 CancellationException 异常。
> 
> 当任务计算出错时，调用get会抛出 ExecutionException 异常。
> 
> 当任务被中断时，调用get会抛出 CancellationException 异常。

** V get(long timeout, TimeUnit unit)  
        throws InterruptedException, ExecutionException, TimeoutException;**

> 相当于给执行的任务线程一个等待时间，当大于某一个等待时间后，就不再等待任务返回的结果，直接抛出TimeoutException异常。
> 
> 第一个参数是 等待时间的长度。
> 
> 第二个参数是 时间长度的单位。 通常通过 TimeUnit.\*\*（工具类）获取对应时间单位。
> 
> 其他抛出的异常和上面无参的get方法一致。

补充知识：

关于中断：

Future接口源码：

package java.util.concurrent;
 
 /**
 * A {@code Future} represents the result of an asynchronous
 * computation. Methods are provided to check if the computation is
 * complete, to wait for its completion, and to retrieve the result of
 * the computation. The result can only be retrieved using method
 * {@code get} when the computation has completed, blocking if
 * necessary until it is ready. Cancellation is performed by the
 * {@code cancel} method. Additional methods are provided to
 * determine if the task completed normally or was cancelled. Once a
 * computation has completed, the computation cannot be cancelled.
 * If you would like to use a {@code Future} for the sake
 * of cancellability but not provide a usable result, you can
 * declare types of the form {@code Future<?>} and
 * return {@code null} as a result of the underlying task.
 *
 * 
 * Sample Usage (Note that the following classes are all
 * made-up.)
 * <pre> {@code
 * interface ArchiveSearcher { String search(String target); }
 * class App {
 * ExecutorService executor = ...
 * ArchiveSearcher searcher = ...
 * void showSearch(final String target)
 * throws InterruptedException {
 * Future<String> future
 * = executor.submit(new Callable<String>() {
 * public String call() {
 * return searcher.search(target);
 * }});
 * displayOtherThings(); // do other things while searching
 * try {
 * displayText(future.get()); // use future
 * } catch (ExecutionException ex) { cleanup(); return; }
 * }
 * }}</pre>
 *
 * The {@link FutureTask} class is an implementation of {@code Future} that
 * implements {@code Runnable}, and so may be executed by an {@code Executor}.
 * For example, the above construction with {@code submit} could be replaced by:
 * <pre> {@code
 * FutureTask<String> future =
 * new FutureTask<String>(new Callable<String>() {
 * public String call() {
 * return searcher.search(target);
 * }});
 * executor.execute(future);}</pre>
 *
 * Memory consistency effects: Actions taken by the asynchronous computation
 * <a href="package-summary.html#MemoryVisibility"> happen-before</a>
 * actions following the corresponding {@code Future.get()} in another thread.
 *
 * @see FutureTask
 * @see Executor
 * @since 1.5
 * @author Doug Lea
 * @param <V> The result type returned by this Future's {@code get} method
 */
 public interface Future<V> {
 
 /**
 * Attempts to cancel execution of this task. This attempt will
 * fail if the task has already completed, has already been cancelled,
 * or could not be cancelled for some other reason. If successful,
 * and this task has not started when {@code cancel} is called,
 * this task should never run. If the task has already started,
 * then the {@code mayInterruptIfRunning} parameter determines
 * whether the thread executing this task should be interrupted in
 * an attempt to stop the task.
 *
 * After this method returns, subsequent calls to {@link #isDone} will
 * always return {@code true}. Subsequent calls to {@link #isCancelled}
 * will always return {@code true} if this method returned {@code true}.
 *
 * @param mayInterruptIfRunning {@code true} if the thread executing this
 * task should be interrupted; otherwise, in-progress tasks are allowed
 * to complete
 * @return {@code false} if the task could not be cancelled,
 * typically because it has already completed normally;
 * {@code true} otherwise
 */
 boolean cancel(boolean mayInterruptIfRunning);
 
 /**
 * Returns {@code true} if this task was cancelled before it completed
 * normally.
 *
 * @return {@code true} if this task was cancelled before it completed
 */
 boolean isCancelled();
 
 /**
 * Returns {@code true} if this task completed.
 *
 * Completion may be due to normal termination, an exception, or
 * cancellation -- in all of these cases, this method will return
 * {@code true}.
 *
 * @return {@code true} if this task completed
 */
 boolean isDone();
 
 /**
 * Waits if necessary for the computation to complete, and then
 * retrieves its result.
 *
 * @return the computed result
 * @throws CancellationException if the computation was cancelled
 * @throws ExecutionException if the computation threw an
 * exception
 * @throws InterruptedException if the current thread was interrupted
 * while waiting
 */
 V get() throws InterruptedException, ExecutionException;
 
 /**
 * Waits if necessary for at most the given time for the computation
 * to complete, and then retrieves its result, if available.
 *
 * @param timeout the maximum time to wait
 * @param unit the time unit of the timeout argument
 * @return the computed result
 * @throws CancellationException if the computation was cancelled
 * @throws ExecutionException if the computation threw an
 * exception
 * @throws InterruptedException if the current thread was interrupted
 * while waiting
 * @throws TimeoutException if the wait timed out
 */
 V get(long timeout, TimeUnit unit)
 throws InterruptedException, ExecutionException, TimeoutException;
 }