Java Callable、Future的两种使用方式

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);
       
       /**
       接下来就可以通过future来获取一些关于Task的运行信息了：
          比如：future.get();来获取最后执行结果
               future.isDown();来判断是否完成
               等等...
        **/
        
         executor.shutdown();

    }
}

class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        //do something;
        return sum;
    }
}

2. 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);
       
         
        //第二种方式
        /**
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        Thread thread = new Thread(futureTask);
        thread.start();
        **/

         /**
       接下来就可以通过futureTask来获取一些关于Task的运行信息了：
          比如：futureTask.get();来获取最后执行结果
               futureTask.isDown();来判断是否完成
               等等...
        **/
       
       executor.shutdown();
    }
}

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

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