在Java编程中，Java利用future及时获取线程运行结果的方法有两种，第一种利用Future的isdone()和get()结合获取，第二种利用java的concurrent包中的CompletionService提供的方法非阻塞获取。

Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。
有了Future就可以进行三段式的编程了，1.启动多线程任务2.处理其他事3.收集多线程任务结果。从而实现了非阻塞的任务调用。在途中遇到一个问题，那就是虽然能异步获取结果，但是Future的结果需要通过isdone来判断是否有结果，或者使用get()函数来阻塞式获取执行结果。这样就不能实时跟踪其他线程的结果状态了，所以直接使用get还是要慎用，最好配合isdone来使用。
有一种更好的方式来实现对任意一个线程运行完成后的结果都能及时获取的办法：使用CompletionService，它内部添加了阻塞队列，从而获取future中的值，然后根据返回值做对应的处理。

利用Future的get()方法阻塞式获取

/**
 * 多线程执行，异步获取结果
 */
public class AsyncThread {
    public static void main(String[] args) {
        AsyncThread t = new AsyncThread();
        List<Future<String>> futureList = new ArrayList<Future<String>>();
        t.generate(3, futureList);
        t.doOtherThings();
        t.getResult(futureList);
    }

    /**
     *  * 生成指定数量的线程，都放入future数组
     */
    public void generate(int threadNum, List<Future<String>> fList) {
        ExecutorService service = Executors.newFixedThreadPool(threadNum);
        for (int i = 0; i < threadNum; i++) {
            //submit与execute的区别在于submit有返回值，一般对应于callable
            Future<String> f = service.submit(getJob(i));
            fList.add(f);
    }
        service.shutdown();
    }

    /**
     *  * other things
     *  
     */
    public void doOtherThings() {
        System.out.println("now is yes");
    }

    /**
     *  * 从future中获取线程结果，打印结果
     *  
     */
    public void getResult(List<Future<String>> fList) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(getCollectJob(fList));
        service.shutdown();
    }

    /**
     *  * 生成指定序号的线程对象
     *  
     */
    public Callable<String> getJob(final int i) {
        final int time = new Random().nextInt(10);
        return new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(1000 * time);
                return "thread-" + i;
            }
        };
    }

    /**
     *  * 生成结果收集线程对象
     */
    public Runnable getCollectJob(final List<Future<String>> fList) {
        return new Runnable() {
            public void run() {
                for (Future<String> future : fList) {
                    try {
                        //如果不采用while(true)将会是阻塞式获取结果
                        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();
                    }
                }
            }
        };
    }
}

使用CompletionService非阻塞获取多线程返回值

public static void main(String[] args) {
        try {
            completionServiceCount();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    /**
     *  * 使用completionService收集callable结果
     *  * @throws ExecutionException
     *  * @throws InterruptedException
     *  
     */
    public static void completionServiceCount() throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(
                executorService);
        int threadNum = 5;
        for (int i = 0; i < threadNum; i++) {
            completionService.submit(getTask(i));
        }
        int sum = 0;
        int temp = 0;
        for (int i = 0; i < threadNum; i++) {
            temp = completionService.take().get();
            sum += temp;
            System.out.print(temp + "\t");
        }
        System.out.println("CompletionService all is : " + sum);
        executorService.shutdown();
    }

    public static Callable<Integer> getTask(final int no) {
        final Random rand = new Random();
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int time = rand.nextInt(100) * 100;
                System.out.println("thead:" + no + " time is:" + time);
                Thread.sleep(time);
                return no;
            }
        };
        return task;
    }

可以看出，CompletionService编程更友好，简洁易懂。