• Java Callable接口与Future接口的两种使用方式


    Java Callable、Future的两种使用方式
    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;
    }
    }

    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);
    }
    ---------------------
    作者:一个行走的民
    来源:CSDN
    原文:https://blog.csdn.net/zhaominpro/article/details/78054046
    版权声明:本文为博主原创文章,转载请附上博文链接!

  • 相关阅读:
    ES6 Promise多步骤操作
    RPN
    全连接层提速
    Fast R-CNN
    smooth L1损失函数
    ROI pooling
    SPP Net
    R-CNN常见问题
    R-CNN
    NMS
  • 原文地址:https://www.cnblogs.com/GarfieldEr007/p/10166065.html
走看看 - 开发者的网上家园