• 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
    版权声明:本文为博主原创文章,转载请附上博文链接!

  • 相关阅读:
    《算法图解》——第六章 广度有限搜索
    《算法图解》——第一章 算法简介
    《算法图解》——第二章 选择排序
    go-json处理的问题
    Go断言
    Go Example--格式化字符串
    Go Example--strings
    Go Example--组合函数
    Go Example--defer
    Go Example--panic
  • 原文地址:https://www.cnblogs.com/GarfieldEr007/p/10166065.html
Copyright © 2020-2023  润新知