Java线程和多线程（十三）——Callable，Future，FutureTask

在Java多线程之中，Callable和Future的使用时非常广泛的。在之前的文章中，我们了解了关于Java线程池基础的一些内容，知道如何提交Runnable的任务。但是，Runnable的任务是无法有返回值，也不能抛出异常的。而有些时候，我们希望一个线程能够有一些返回值。在Java 5中，引入了java.util.concurrent.Callable接口，这个接口很类似于Runnable接口，但是可以返回一个对象，或者抛出异常。

Java Callable

Java的Callable接口使用了泛型来定义返回的对象的类型。Executors类提供了一些很实用的方法来在线程池中执行Callable的任务。因为Callable的任务通过并行的方式来运行，所以我们需要等待返回的对象。

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;
}

Java Future

Java的Callable对象返回的就是java.util.concurrent.Future对象。通过使用Java Future对象，我们可以知道Callable任务的执行状态，并且获得返回的对象。Future接口提供get()方法来让开发者可以等待Callable任务的执行，然后获得对应的结果。

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;
}

Java Future提供了一个cancel()方法来取消关联的Callable任务的执行。其中的get()方法是包含一个重载的方法的，我们可以指定等待的时间，而不需要无限期的等待Callable任务的执行。这个方法可以有效的防止一个线程的无限期的阻塞。
Future也提供一个isDone()和一个isCancelled()方法来找到其关联的Callable任务的执行状态。

下面是使用Callable的例子，是在一秒之后返回执行任务的名字。我们通过使用Executor框架来并行执行100个任务，然后用Future来获得任务的执行结果。

package com.sapphire.threads;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        //return the thread name executing this callable task
        return Thread.currentThread().getName();
    }

    public static void main(String args[]){
        //Get ExecutorService from Executors utility class, thread pool size is 10
        ExecutorService executor = Executors.newFixedThreadPool(10);
        //create a list to hold the Future object associated with Callable
        List<Future<String>> list = new ArrayList<Future<String>>();
        //Create MyCallable instance
        Callable<String> callable = new MyCallable();
        for(int i=0; i< 100; i++){
            //submit Callable tasks to be executed by thread pool
            Future<String> future = executor.submit(callable);
            //add Future to the list, we can get return value using Future
            list.add(future);
        }
        for(Future<String> fut : list){
            try {
                //print the return value of Future, notice the output delay in console
                // because Future.get() waits for task to get completed
                System.out.println(new Date()+ "::"+fut.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        //shut down the executor service now
        executor.shutdown();
    }
}

当我们运行上面程序的时候，我们的输出会有延迟，因为Future的get()方法会一直等待Callable的任务执行完毕。同时需要注意的是，线程池中，我们仅仅会有10个线程来处理之前定义的Callable任务。

下面是上面程序的输出结果：

Mon Dec 31 20:40:15 PST 2012::pool-1-thread-1
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-3
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-4
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-5
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-6
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-7
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-8
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-9
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-10
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2
...

当我们想要覆盖掉Future接口的一些行为的时候，举例来说，假设我们需要覆盖其中的get()方法来做一些超时处理而不进行持续等待等操作的时候。Java中的FutureTask类在这种时候就会非常有用了，它是Future接口的实现类。

FutureTask

在上面，我们了解到使用Callable以及Future接口来处理多线程的一些便利之处。

而FutureTask是Future接口的一个基础实现，并且提供了异步处理的功能，FutureTask包含了一些方法来启动或者取消任务，也包含一些方法来返回Future的状态，来确认Future是完成了还是去掉了。我们需要一个Callable对象来创建一个FutureTask然后，我们可以通过ThreadPoolExecutor来异步处理这些任务。

下面是FutureTask的代码举例，因为FutureTask是需要Callable的，所以我们来创建一个Callable的实现：

package com.sapphire.threads;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private long waitTime;

    public MyCallable(int timeInMillis){
        this.waitTime=timeInMillis;
    }
    @Override
    public String call() throws Exception {
        Thread.sleep(waitTime);
        //return the thread name executing this callable task
        return Thread.currentThread().getName();
    }

}

下面是一个FutureTask方法的例子，下面展示的是关于使用FutureTask方法的一些举例：

package com.sapphire.threads;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class FutureTaskExample {

    public static void main(String[] args) {
        MyCallable callable1 = new MyCallable(1000);
        MyCallable callable2 = new MyCallable(2000);

        FutureTask<String> futureTask1 = new FutureTask<String>(callable1);
        FutureTask<String> futureTask2 = new FutureTask<String>(callable2);

        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(futureTask1);
        executor.execute(futureTask2);

        while (true) {
            try {
                if(futureTask1.isDone() && futureTask2.isDone()){
                    System.out.println("Done");
                    //shut down executor service
                    executor.shutdown();
                    return;
                }

                if(!futureTask1.isDone()){
                    //wait indefinitely for future task to complete
                    System.out.println(
                        "FutureTask1 output="+futureTask1.get());
                }

                System.out.println("Waiting for FutureTask2 to complete");
                String s = futureTask2.get(200L, TimeUnit.MILLISECONDS);
                if(s !=null){
                    System.out.println("FutureTask2 output="+s);
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }catch(TimeoutException e){
                //do nothing
            }
        }
    }
}

当我们运行上面的程序，你会发现，有一段时间是不会输出任何东西到控制台的，因为FutureTask的get()方法会等待任务的完成，然后才会返回输出的对象。在FutureTask中也有一个重载的方法会等待指定的时间。需要注意的是，当调用isDone()方法来确定程序一旦结束，任务也会完成。

输出如下：

FutureTask1 output=pool-1-thread-1
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
FutureTask2 output=pool-1-thread-2
Done

从上面的例子来说是没有使用到FutureTask的便利之处的，但是当我们想要覆盖掉Future接口方法的实现，而不像实现Future接口的每一个方法的时候，我们就可以考虑使用FutureTask。