Java：多线程，线程池，使用CompletionService通过Future来处理Callable的返回结果

1. 背景

在Java5的多线程中，可以使用Callable接口来实现具有返回值的线程。使用线程池的submit方法提交Callable任务，利用submit方法返回的Future存根，调用此存根的get方法来获取整个线程池中所有任务的运行结果。

方法一：如果是自己写代码，应该是自己维护一个Collection保存submit方法返回的Future存根，然后在主线程中遍历这个Collection并调用Future存根的get()方法取到线程的返回值。

方法二：使用CompletionService类，它整合了Executor和BlockingQueue的功能。你可以将Callable任务提交给它去执行，然后使用类似于队列中的take方法获取线程的返回值。

2. 实现代码

package base2;

import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;

public class ThreadPoolTest4 {
    // 具有返回值的测试线程
    class MyThread implements Callable<String> {
        private String name;
        private String method;
        public MyThread(String name,String method) {
            this.name = name;
            this.method = method;
        }

        @Override
        public String call() {
            int sleepTime = new Random().nextInt(1000);
            try {
                Thread.sleep(sleepTime);
//                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 返回给调用者的值
            String str = name + " sleep time:" + sleepTime;
            System.out.println(method+"-->>"+name + "-->> finished...");

            return str;
        }
    }

    private final int POOL_SIZE = 5;
    private final int TOTAL_TASK = 10;

    // 方法一，自己写集合来实现获取线程池中任务的返回结果
    public void testByQueue() throws Exception {
        // 创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(POOL_SIZE);
        BlockingQueue<Future<String>> queue = new LinkedBlockingQueue<Future<String>>();

        // 向里面扔任务
        for (int i = 0; i < TOTAL_TASK; i++) {
            Future<String> future = pool.submit(new MyThread("Thread" + i,"方法一"));
            queue.add(future);
        }

        // 检查线程池任务执行结果
        for (int i = 0; i < TOTAL_TASK; i++) {
            System.out.println("method1:" + queue.take().get());
        }

        // 关闭线程池
        pool.shutdown();
        System.out.println("\n\n\n");
    }

    // 方法二，通过CompletionService来实现获取线程池中任务的返回结果
    public void testByCompetion() throws Exception {
        // 创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(POOL_SIZE);
        CompletionService<String> cService = new ExecutorCompletionService<String>(pool);

        // 向里面扔任务
        for (int i = 0; i < TOTAL_TASK; i++) {
            cService.submit(new MyThread("Thread" + i,"方法二"));
        }

        // 检查线程池任务执行结果
        for (int i = 0; i < TOTAL_TASK; i++) {
            Future<String> future = cService.take();
            System.out.println("method2:" + future.get());
        }

        // 关闭线程池
        pool.shutdown();
    }

    public static void main(String[] args) throws Exception {
        ThreadPoolTest4 t = new ThreadPoolTest4();
        t.testByQueue();
        t.testByCompetion();
    }
}

部分输出：

方法一-->>Thread2-->> finished...
方法一-->>Thread3-->> finished...
方法一-->>Thread1-->> finished...
方法一-->>Thread7-->> finished...
方法一-->>Thread4-->> finished...
方法一-->>Thread5-->> finished...
方法一-->>Thread0-->> finished...
method1:Thread0 sleep time:895
method1:Thread1 sleep time:319
method1:Thread2 sleep time:9
method1:Thread3 sleep time:307
method1:Thread4 sleep time:642
method1:Thread5 sleep time:708
方法一-->>Thread8-->> finished...
方法一-->>Thread9-->> finished...
方法一-->>Thread6-->> finished...
method1:Thread6 sleep time:983
method1:Thread7 sleep time:229
method1:Thread8 sleep time:545
method1:Thread9 sleep time:578

方法二-->>Thread1-->> finished...
method2:Thread1 sleep time:90
方法二-->>Thread4-->> finished...
method2:Thread4 sleep time:137
方法二-->>Thread2-->> finished...
method2:Thread2 sleep time:519
方法二-->>Thread5-->> finished...
method2:Thread5 sleep time:480
方法二-->>Thread3-->> finished...
method2:Thread3 sleep time:767
方法二-->>Thread0-->> finished...
method2:Thread0 sleep time:887
方法二-->>Thread6-->> finished...
method2:Thread6 sleep time:787
方法二-->>Thread7-->> finished...
method2:Thread7 sleep time:527
方法二-->>Thread9-->> finished...
method2:Thread9 sleep time:411
方法二-->>Thread8-->> finished...
method2:Thread8 sleep time:994

3. 总结

使用方法一，自己创建一个集合来保存Future存根并循环调用其返回结果的时候，主线程并不能保证首先获得的是最先完成任务的线程返回值。它只是按加入线程池的顺序返回。因为take方法是阻塞方法，后面的任务完成了，前面的任务却没有完成，主程序就那样等待在那儿，只到前面的完成了，它才知道原来后面的也完成了。

使用方法二，使用CompletionService来维护处理线程不的返回结果时，主线程总是能够拿到最先完成的任务的返回值，而不管它们加入线程池的顺序。

这两者最主要的区别在于submit的task不一定是按照加入自己维护的list顺序完成的。

从list中遍历的每个Future对象并不一定处于完成状态，这时调用get()方法就会被阻塞住，如果系统是设计成每个线程完成后就能根据其结果继续做后面的事，这样对于处于list后面的但是先完成的线程就会增加了额外的等待时间。

而CompletionService的实现是维护一个保存Future对象的BlockingQueue。只有当这个Future对象状态是结束的时候，才会加入到这个Queue中，take()方法其实就是Producer-Consumer中的Consumer。它会从Queue中取出Future对象，如果Queue是空的，就会阻塞在那里，直到有完成的Future对象加入到Queue中。

所以，先完成的必定先被取出。这样就减少了不必要的等待时间。