Java Callable、Future的两种使用方式

1. Callable+Future

public class Test {    public static void main(String[] args) {        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        Future<Integer> future = executor.submit(task);        executor.shutdown();       /**       接下来就可以通过future来获取一些关于Task的运行信息了：          比如：future.get();来获取最后执行结果               future.isDown();来判断是否完成               等等...        **/    }}class Task implements Callable<Integer>{    @Override    public Integer call() throws Exception {        int sum = 0;        //do something;        return sum;    }}

1. Callable+FutureTask

public class Test {    public static void main(String[] args) {        //第一种方式        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        executor.submit(futureTask);        executor.shutdown();        //第二种方式        /**        Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        Thread thread = new Thread(futureTask);        thread.start();        **/         /**       接下来就可以通过futureTask来获取一些关于Task的运行信息了：          比如：futureTask.get();来获取最后执行结果               futureTask.isDown();来判断是否完成               等等...        **/    }}class Task implements Callable<Integer>{    @Override    public Integer call() throws Exception {        int sum = 0;        //do something;        return sum;    }}

以上出自这篇博客，感谢作者。链接：http://www.cnblogs.com/dolphin0520/p/3949310.html

但其实这两种方法最终是一样的：

第一种方式Callable+Future最终也是以Callable+FutureTask的形式实现的。
在第一种方式中调用了： Future future = executor.submit(task);
那就让我们看看executor.submit(task)的源码吧：

//java.util.concurrent.AbstractExecutorService类中   /**     * @throws RejectedExecutionException {@inheritDoc}     * @throws NullPointerException       {@inheritDoc}     */    public <T> Future<T> submit(Callable<T> task) {        if (task == null) throw new NullPointerException();        RunnableFuture<T> ftask = newTaskFor(task);//可以看到源码中其实是在submit(Callable<T> task)内部创建了一个RunnableFuture<T>接口实现类        execute(ftask);        return ftask;    }

而FutureTask又是RunnableFuture的实现类，那就再看看newTaskFor(Callable callable)里面干了什么：

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

现在清楚了吧。两种方式最终是同样实现的。至于其他优劣之处暂时我也没想到。以后再总结