Callable/Future

Posted 2020-09-16

Callable 和 Future 是比较有趣的一对组合。当我们需要获取线程的执行结果时，就需要用到它们。Callable用于产生结果，Future用于获取结果。

第1部分 Callable

　　Callable 是一个接口，它只包含一个call()方法。Callable是一个返回结果并且可能抛出异常的任务。

为了便于理解，我们可以将Callable比作一个Runnable接口，而Callable的call()方法则类似于Runnable的run()方法。

Callable的源码如下：

public interface Callable<V> {
    V call() throws Exception;
}

　　Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。

Executors 类包含一些从其他普通形式转换成 Callable 类的实用方法。

 

第2部分 Future

　　Future 是一个接口。它用于表示异步计算的结果。提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。

Future的源码如下：

 boolean cancel(boolean mayInterruptIfRunning) 
          试图取消对此任务的执行。 
 V get() 
          如有必要，等待计算完成，然后获取其结果。 
 V get(long timeout, TimeUnit unit) 
          如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。 
 boolean isCancelled() 
          如果在任务正常完成前将其取消，则返回 true。 
 boolean isDone() 
          如果任务已完成，则返回 true。 

 

在讲解FutureTask之前，先看看Callable, Future, FutureTask它们之间的关系图，如下：

 

　　Future表示一个任务的生命周期，并提供了相应的方法来判断是否已经完成或取消，以及获取任务的结果和取消任务等。在Future规范中包含的隐含意义是，任务的生命周期只能前进，不能后退，就像ExecutorService的生命周期一样。当某个任务完成以后，它就永远停留在“完成”状态上。

　　get方法的行为取决于任务的状态（尚未开始、正在运行、已完成）。如果任务已经完成，那么get会立即返回或者抛出一个Exception，如果任务没有完成，那么get将阻塞并直到任务完成。如果任务抛出了异常，那么get将该异常封装为ExecutionException并重新抛出。如果任务被取消，那么get将抛出CancellationException。如果get抛出了ExecutionException，那么可以通过getCause来获得封装的初始异常。

异常抛出： 
CancellationException - 如果计算被取消 
ExecutionException - 如果计算抛出异常 
InterruptedException - 如果当前的线程在等待时被中断 
TimeoutException - 如果等待超时

 

　　可以通过很多种方法创建一个Future来描述任务。ExecutorService中的所有submit方法都将返回一个Future，从而将一个Runnable 或 Callable 提交给Executor ，并得到一个Future 用来获得任务的执行结果或者取消任务。 还可以显示地为某个任务指定的Runnable或Callable 实例化一个FutureTask。

 

说明：
(01) RunnableFuture是一个接口，它继承了Runnable和Future这两个接口。RunnableFuture的源码如下：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

 

(02) FutureTask实现了RunnableFuture接口。所以，也说它实现了Future接口。

 

第3部分 示例和源码分析

先通过一个示例看看Callable和Future的基本用法，然后再分析示例的实现原理。

 

 1 package com.concurrency.TaskExecution_6;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.ExecutionException;
 5 import java.util.concurrent.ExecutorService;
 6 import java.util.concurrent.Executors;
 7 import java.util.concurrent.Future;
 8 
 9 /**
10  * Callable 和 Future实现线程等待
11  * @ClassName: CallableFutureTest
12  * @author Xingle
13  * @date 2014-9-15 下午3:23:30
14  */
15 public class CallableFutureTest {
16     
17     public static void main(String[] args) throws InterruptedException, ExecutionException{
18         System.out.println("start main thread ");
19         ExecutorService exec = Executors.newFixedThreadPool(5);
20         
21         //新建一个Callable 任务，并将其提交到一个ExecutorService. 将返回一个描述任务情况的Future.
22         Callable<String> call = new Callable<String>() {
23 
24             @Override
25             public String call() throws Exception {
26                 System.out.println("start new thread ");
27                 Thread.sleep(5000);
28                 System.out.println("end new thread ");
29                 return "返回内容";
30             }
31         };
32         
33         Future<String> task = exec.submit(call);
34         Thread.sleep(1000);
35         String retn = task.get();
36         //关闭线程池
37         exec.shutdown();
38         System.out.println(retn+"--end main thread");
39     }
40 
41 }

 

执行结果：

 

3.1 submit()

submit()在java/util/concurrent/AbstractExecutorService.java中实现，它的源码如下：

1 public <T> Future<T> submit(Callable<T> task) {
2     if (task == null) throw new NullPointerException();
3     // 创建一个RunnableFuture对象
4     RunnableFuture<T> ftask = newTaskFor(task);
5     // 执行“任务ftask”
6     execute(ftask);
7     // 返回“ftask”
8     return ftask;
9 }

 

说明：submit()通过newTaskFor(task)创建了RunnableFuture对象ftask。它的源码如下：

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

 

3.2 FutureTask的构造函数

FutureTask的构造函数如下：

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    // callable是一个Callable对象
    this.callable = callable;
    // state记录FutureTask的状态
    this.state = NEW;       // ensure visibility of callable
}

 

3.3 FutureTask的run()方法

继续回到submit()的源码中。
在newTaskFor()新建一个ftask对象之后，会通过execute(ftask)执行该任务。此时ftask被当作一个Runnable对象进行执行，最终会调用到它的run()方法；ftask的run()方法在java/util/concurrent/FutureTask.java中实现，源码如下：

 1 public void run() {
 2     if (state != NEW ||
 3         !UNSAFE.compareAndSwapObject(this, runnerOffset,
 4                                      null, Thread.currentThread()))
 5         return;
 6     try {
 7         // 将callable对象赋值给c。
 8         Callable<V> c = callable;
 9         if (c != null && state == NEW) {
10             V result;
11             boolean ran;
12             try {
13                 // 执行Callable的call()方法，并保存结果到result中。
14                 result = c.call();
15                 ran = true;
16             } catch (Throwable ex) {
17                 result = null;
18                 ran = false;
19                 setException(ex);
20             }
21             // 如果运行成功，则将result保存
22             if (ran)
23                 set(result);
24         }
25     } finally {
26         runner = null;
27         // 设置“state状态标记”
28         int s = state;
29         if (s >= INTERRUPTING)
30             handlePossibleCancellationInterrupt(s);
31     }
32 }

 

说明：run()中会执行Callable对象的call()方法，并且最终将结果保存到result中，并通过set(result)将result保存。
　　    之后调用FutureTask的get()方法，返回的就是通过set(result)保存的值。

 http://www.cnblogs.com/xingele0917/p/3973140.html