java Callable、Future、FutureTask接口

前言

一般而言，线程的创建方法有两种，一种是继承Thread类，另一种是实现Runnable接口。

但是这两种方法都有一个问题：那就是在任务执行完成之后无法获取返回结果。于是就有了Callable接口，Future接口与FutureTask类的配和取得返回的结果。这也是所谓的“异步”模型。

 

Callable 接口介绍

首先回顾一下java.lang.Runnable接口，就声明了run(),其返回值为void，当然就无法获取结果。

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

而Callable的接口如下：

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

该接口声明了一个名称为call()的方法，同时这个方法可以有返回值V，也可以抛出异常。

 

那么Callable接口是怎么使用的呢？

无论是Runnable接口的实现类还是Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行，ThreadPoolExecutor或ScheduledThreadPoolExecutor都实现了ExcutorService接口，而因此Callable需要和Executor框架中的ExcutorService结合使用，我们先看看ExecutorService提供的方法：

<T> Future<T> submit(Callable<T> task);  
<T> Future<T> submit(Runnable task, T result);  
Future<?> submit(Runnable task);  

第一个方法：submit提交一个实现Callable接口的任务，并且返回封装了异步计算结果的Future。

第二个方法：submit提交一个实现Runnable接口的任务，并且指定了在调用Future的get方法时返回的result对象。（不常用）

第三个方法：submit提交一个实现Runnable接口的任务，并且返回封装了异步计算结果的Future。

因此我们只要创建好我们的线程对象（实现Callable接口或者Runnable接口），然后通过上面3个方法提交给线程池去执行即可。还有点要注意的是，除了我们自己实现Callable对象外，我们还可以使用工厂类Executors来把一个Runnable对象包装成Callable对象。Executors工厂类提供的方法如下：

public static Callable<Object> callable(Runnable task)  

public static <T> Callable<T> callable(Runnable task, T result)  

 

测试代码

public class Task implements Callable {

    @Override
    public String call() throws Exception {
        return "call()方法";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Task task = new Task();
        Future<String> submit = executorService.submit(task);
        System.out.println(submit.get());
    }
}

输出结果：call()方法

 

Future<V> 接口介绍

Future<V>接口是用来获取异步计算结果的，说白了就是对具体的Runnable或者Callable对象任务执行的结果进行获取(get()),取消(cancel()),判断是否完成等操作。我们看看Future接口的源码：

    public interface Future<V> {  
        boolean cancel(boolean mayInterruptIfRunning);  
        boolean isCancelled();  
        boolean isDone();  
        V get() throws InterruptedException, ExecutionException;  
        V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;  
    }  

方法说明：

V get() ：获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。

V get(Long timeout , TimeUnit unit) ：获取异步执行结果，如果没有结果可用，此方法会阻塞，但是会有时间限制，如果阻塞时间超过设定的timeout时间，该方法将抛出异常。

boolean isDone() ：如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。

boolean isCancelled() ：如果任务完成前被取消，则返回true。

boolean cancel(boolean mayInterruptRunning) ：

• 如果任务还没开始，执行cancel(...)方法将返回false；
• 如果任务已经启动，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果停止成功，返回true；
• 当任务已经启动，执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时返回false；
• 当任务已经完成，执行cancel(...)方法将返回false。

cancel()注意是试图取消，并不一定能取消成功。因为任务可能已完成、已取消、或者一些其它因素不能取消，存在取消失败的可能。boolean类型的返回值是“是否取消成功”的意思。参数mayInterruptRunning表示是否采用中断的方式取消线程执行。

通过方法分析我们也知道实际上Future提供了3种功能：（1）能够中断执行中的任务（2）判断任务是否执行完成（3）获取任务执行完成后的结果。

 

测试代码

• 使用Callable+Future获取执行结果

Callable实现类如下：

 1 import java.util.concurrent.Callable;  
 2 
 3 public class CallableDemo implements Callable<Integer> {  
 4       
 5     private int sum;  
 6     @Override  
 7     public Integer call() throws Exception {  
 8         System.out.println("Callable子线程开始计算啦！");  
 9         Thread.sleep(2000);  
10           
11         for(int i=0 ;i<5000;i++){  
12             sum=sum+i;  
13         }  
14         System.out.println("Callable子线程计算结束！");  
15         return sum;  
16     }  
17 } 

 

Callable执行测试类如下：

 1 public class CallableTest {
 2     public static void main(String[] args) {
 3         //创建线程池  
 4         ExecutorService es = Executors.newSingleThreadExecutor();
 5         //创建Callable对象任务  
 6         CallableDemo calTask=new CallableDemo();
 7         //提交任务并获取执行结果  
 8         Future<Integer> future =es.submit(calTask);
 9         //关闭线程池  
10         es.shutdown();
11         try {
12             Thread.sleep(2000);
13             System.out.println("主线程在执行其他任务");
14 
15             if(future.get()!=null){
16                 //输出获取到的结果  
17                 System.out.println("future.get()-->"+future.get());
18             }else{
19                 //输出获取到的结果  
20                 System.out.println("future.get()未获取到结果");
21             }
22 
23         } catch (Exception e) {
24             e.printStackTrace();
25         }
26         System.out.println("主线程在执行完成");
27     }
28 }

执行结果：

1 Callable子线程开始计算啦！
2 主线程在执行其他任务
3 Callable子线程计算结束！
4 future.get()-->12497500
5 主线程在执行完成

 

但是我们必须明白Future只是一个接口，我们无法直接创建对象，因此就需要其实现类FutureTask登场啦。

 

FutureTask类

FutureTask的几个状态

    /**
     * The run state of this task, initially NEW.  The run state
     * transitions to a terminal state only in methods set,
     * setException, and cancel.  During completion, state may take on
     * transient values of COMPLETING (while outcome is being set) or
     * INTERRUPTING (only while interrupting the runner to satisfy a
     * cancel(true)). Transitions from these intermediate to final
     * states use cheaper ordered/lazy writes because values are unique
     * and cannot be further modified.
     *
     * Possible state transitions:
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INTERRUPTED
     */
    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;

 

先来看看FutureTask的实现

public class FutureTask<V> implements RunnableFuture<V> { ...}

FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：

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

分析：FutureTask除了实现了Future接口外还实现了Runnable接口（既可以通过Runnable接口实现线程，也可以通过Future取得线程执行完后的结果），因此FutureTask也可以直接提交给Executor执行。

最后我们给出FutureTask的两种构造函数：

public FutureTask(Callable<V> callable) {  
}  

public FutureTask(Runnable runnable, V result) {  
}  

 

那FutureTask类有什么用？为什么要有一个FutureTask类？

前面说到了Future只是一个接口，而它里面的cancel，get，isDone等方法要自己实现起来都是非常复杂的。所以JDK提供了一个FutureTask类来供我们使用。

 

测试代码

• 使用Callable+FutureTask获取执行结果

Callable实现类不变，测试类如下

public class CallableTest {
    public static void main(String[] args) {
        //创建线程池  
        ExecutorService es = Executors.newSingleThreadExecutor();
        //创建Callable对象任务  
        CallableDemo calTask=new CallableDemo();
        //创建FutureTask  
        FutureTask<Integer> futureTask=new FutureTask<>(calTask);
        //执行任务  
        es.submit(futureTask);
        //关闭线程池  
        es.shutdown();
        try {
            Thread.sleep(2000);
            System.out.println("主线程在执行其他任务");

            if(futureTask.get()!=null){
                //输出获取到的结果  
                System.out.println("futureTask.get()-->"+futureTask.get());
            }else{
                //输出获取到的结果  
                System.out.println("futureTask.get()未获取到结果");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("主线程在执行完成");
    }
} 

 

执行结果：

Callable子线程开始计算啦！
主线程在执行其他任务
Callable子线程计算结束！
futureTask.get()-->12497500
主线程在执行完成