Java并发编程二：Callable Future

概述

在jdk1.5之前，线程的创建有两种方式：一种是直接继承Thread，另外一种就是实现Runnable接口。

但这2种方式都存在一个问题就是：在执行完任务之后无法获取执行结果。如果需要获取执行结果，就必须通过共享变量或者消息传递的方式来达到效果，这样使用起来就比较麻烦。

从Java 1.5开始，就提供了Callable类和Future类，通过它们可以在任务执行完毕之后得到任务执行结果。经过分析和总结，我们把异步计算的线程按照职责分为3部分：

计算模型

1、控制器（Controller）：异步计算的控制线程，负责异步计算任务的分解和发起，把分解好的任务交给异步计算的worker线程去执行，发起异步计算后，controller可以获得Futrue的集合，将集合数据传递给collector，collector根据Future的状态来处理异步计算的结果；

2、处理器（Wroker）:异步计算线程，负责具体的计算任务；

3、结果收集器（Collector）:异步计算结果收集线程，从发起线程那里获得Future的集合，并负责监控Future的状态，根据Future的状态来处理异步计算的结果。

根据以上模型，构建的异步计算代码如下：

控制器

package com.ips.concurrent.future;import java.util.ArrayList;import java.util.List;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;/** * <p> * Title: TaskController * </p> * <p> * Description: 异步计算的控制线程（controller）：负责异步计算任务的分解和发起，把分解好的任务交给异步计算的worker线程去执行，发起异步计算后， * controller可以获得Futrue的集合，将集合数据传递给collector，collector根据Future的状态来处理异步计算的结果。 * </p> *  * @author liuzhibo * @date 2016年7月29日 */public class TaskController {    ExecutorService executor = null;    List<Future<Integer>> list = null;    public TaskController() {        executor = Executors.newFixedThreadPool(100);        list = new ArrayList<Future<Integer>>();    }    public void work() {        System.out.println("Start processing : ");        TaskWorker task = null;        Future<Integer> future = null;        for (int i = 0; i < 100; i++) {            task = new TaskWorker();            future = this.executor.submit(task);            list.add(future);        }        /**         * 当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态,以后不能再往线程池中添加任何任务，         * 否则将会抛出RejectedExecutionException异常。但是，此时线程池不会立刻退出，直到添加到线程池中的任务都已经处理完成         * ，才会退出。 与它相似的还有一个shutdownNow()，它通过调用Thread.interrupt来实现线程的立即退出。         **/        this.executor.shutdown();        System.out.println("Finish processing. ");    }    public void collect() {        TaskCollector<Integer> task = new TaskCollector<Integer>(list);        Thread thread = new Thread(task);        thread.start();    }    public static void main(String[] args) {        // 定义异步计算的控制对象        TaskController controller = new TaskController();        // 启动异步计算任务        controller.work();        // 对异步计算结果进行收集        controller.collect();    }}

处理器

package com.ips.concurrent.future;import java.util.Random;import java.util.concurrent.Callable;/** * <p>Title: ProcessTask</p> * <p>Description: 异步计算线程（worker），负责具体的计算任务</p> * @author  liuzhibo * @date    2016年7月29日 */public class TaskWorker implements Callable<Integer>{    final Random random = new Random();      @Override    public Integer call() throws Exception {         int randomInt = random.nextInt(10);           Thread.sleep(randomInt * 1000);           return randomInt;     }}

收集器

package com.ips.concurrent.future;import java.util.ArrayList;import java.util.List;import java.util.concurrent.Future;/** * <p> * Title: CollectTask * </p> * <p> * Description: 异步计算结果收集线程（collector），从发起线程那里获得Future的集合，并负责监控Future的状态， * 根据Future的状态来处理异步计算的结果。 * </p> *  * @author liuzhibo * @date 2016年7月29日 */public class TaskCollector<T> implements Runnable {    private List<Future<T>> list = new ArrayList<Future<T>>();    public TaskCollector(List<Future<T>> list) {        this.list = list;    }    @Override    public void run() {        System.out.println("Start collecting : ");        //由于Future的计算结果并不是按照list中的顺序进行返回的，以下代码存在性能问题，因此此处可以进行优化        for (Future<T> future : list) {            try {                while (true) {                    if (future.isDone() && !future.isCancelled()) {                        System.out.println("Future : " + future + ", Result : " + future.get());                        break;                    } else {                        Thread.sleep(1000);                    }                }            } catch (Exception e) {                e.printStackTrace();            }        }        System.out.println("Finish collecting.");    }}