线程池原理（七）：线程池的使用

这篇文章通过介绍线程池的常见用法，总结前面学习到的内容。

主要包括

1. ThreadPoolExecutor的使用
2. ScheduledThreadPoolExecutor的使用
3. ExecutorCompletionService的使用

1. 统计某个区间内数字和

这是一个常见的问题，比如计算1到1000000之间的数字和，通常情况下，一个线程去遍历计算即可，既然学到了多线程，我们可以将该任务切割，分成多个子任务并交给线程池来解决，子任务解决后将这些任务的结果归并，就可以得到我们要的值了。虽然这个问题很简单，但是它的解决思路可以用于解决其他类似的问题。

先看下面代码：

public class AsyncEngine {    /**     * 线程池的线程数量不需要太多，它是和CPU核数量有关，太多反而上下文切换效率不好     */    private static ExecutorService executorService =      new ThreadPoolExecutor(2, 10, 30, TimeUnit.SECONDS, new SynchronousQueue());    /**     * 定时任务线程池     */    private static ScheduledExecutorService scheduledExecutorService      = new ScheduledThreadPoolExecutor(2);    /**     * 完成服务线程池     */    private static CompletionService completionService       = new ExecutorCompletionService(executorService);    /**     * 异步执行任务，所有任务执行完成后该方法才返回，如果任务执行失败，该任务返回值为null     * @param tasks 待执行的任务     * @param <T> 任务的返回值     * @return     */    public static  <T> List<T> concurrentExecute(List<Callable<T>> tasks) {        if (tasks == null || tasks.size() == 0) {            return Lists.newArrayList();        }        List<T> res = Lists.newArrayList();        try {            List<Future<T>> futures = executorService.invokeAll(tasks);            for (Future<T> future : futures) {                T t = null;                try {                    t = future.get();                } catch (ExecutionException e) {                    e.printStackTrace();                } catch (Throwable e) {                    e.printStackTrace();                }                res.add(t);            }        } catch (InterruptedException e) {            e.printStackTrace();        }        return res;    }    /**     * 定时执行任务     * @param runnable 执行的任务     * @param initialDelay 初始延时     * @param delay 任务间的等待时间     * @param unit 时间单位     * @return     */    public static ScheduledFuture<?> scheduledWithFixedDelay(Runnable runnable,                                                             long initialDelay,                                                             long delay, TimeUnit unit) {        return scheduledExecutorService.scheduleWithFixedDelay(runnable,                                                               initialDelay,                                                               delay, unit);    }    /**     * 完成服务     * @param tasks     * @param <T>     * @return     */    public static <T> CompletionService completionExecute(List<Callable<T>> tasks) {        if (tasks == null || tasks.size() == 0) {            return completionService;        }        for (Callable<T> task : tasks) {            completionService.submit(task);        }        return completionService;    }}

这段代码是在项目中实际使用的代码，只是作了部分改动，它是一个异步执行引擎，方法concurrentExecute并发执行任务，当这些任务执行完成后，该方法才会返回。我们定义了一个线程池，指定核心线程数为2，最大线程数为10，线程数定义太大无意义，因为它是和CPU核数是有关系的。

concurrentExecute方法中，调用线程池的invokeAll方法，该方法返回Future的列表，然后遍历该列表，Future的get方法会阻塞，直到该任务执行完成，将任务返回结果放入List中。注意，当任务抛出异常时，返回结果为null，该null值也一并放到List中作为concurrentExecute方法的返回值。

有了这个异步执行引擎，我们继续看下怎么实现统计某个区间内的数字和，看下代码：

public class Sum {    /**     * 多线程并发计算     * @param min     * @param max     * @return     */    public static long sum1(int min, int max) {        if (min > max) {            return 0L;        }        List<Callable<Long>> tasks = Lists.newArrayList();        while (min < max) {            final int left = min;            final int right = max;            //分割任务，每个任务最多只相加1000个数            Callable<Long> task = new Callable<Long>() {                @Override                public Long call() throws Exception {                    long sum = 0;                    int r = (left + 1000) < right ? (left + 1000) : right;                    for (int i = left; i < r; i++) {                        sum += i;                    }                    return sum;                }            };            tasks.add(task);            min += 1000;        }        //异步执行，执行完成后该方法返回        List<Long> res = AsyncEngine.concurrentExecute(tasks);        long sum = 0;        //归并结果        for (Long count : res) {            sum += count;        }        return sum;    }    /**     * 单线程计算     * @param min     * @param max     * @return     */    public static long sum2(int min, int max) {        long sum = 0;        for (int i = min; i < max; i++) {            sum += i;        }        return sum;    }    public static void main(String[] args) {        System.out.println(sum1(4, 9999));        System.out.println(sum2(4, 9999));    }}

并发统计和的重点在于分割任务，每个任务最多相加1000个数字。子任务分割完成后，一并交给异步执行引擎处理，返回一个列表，该列表保存了每个任务的返回值，最后归并这个列表即可。这段代码也给出了单线程的代码，便于对比。

2. 定时任务

这里的定时任务很简单，5秒过后开始执行任务，任务执行完成等待1秒再次执行该任务，模拟闹钟的秒针运行，每秒嘀嗒一次。上面讲到的异步引擎AsyncEngine已经写好了定时相关的代码，直接运行目标任务即可。

public class Alarm {    public static void main(String[] args) {        Runnable runnable = new Runnable() {            @Override            public void run() {                System.out.println("da");            }        };        //定时调度，模拟时钟的秒针运行        AsyncEngine.scheduledWithFixedDelay(runnable, 5, 1, TimeUnit.SECONDS);    }}

3. 完成服务

利用CompletionService来实现生产者消费者模式，对于第一个例子中讲到的统计区间数字和，主线程其实就是一个消费者，线程池中的线程是生产者，这些生产者计算各个任务，消费者等待这些任务执行结束。

这里面的问题是，通过concurrentExecute方法执行任务，需要等到所有任务执行结束该方法才能返回，如果某些任务已经完成，消费者能够即时的消费，显然更加合理。因此我们在AsyncEngine里添加了completionExecute方法，这个方法提交所有的任务到线程池，返回CompletionService。消费者（主线程）通过CompletionService的take方法取任务Future，取到的Future肯定是已经结束的任务，当take方法阻塞，说明还没有已经结束的任务。看下Sum类的实现：

public class Sum {    /**     * 多线程并发计算     * @param min     * @param max     * @return     */    public static long sum1(int min, int max) {        if (min > max) {            return 0L;        }        List<Callable<Long>> tasks = Lists.newArrayList();        while (min < max) {            final int left = min;            final int right = max;            //分割任务，每个任务最多只相加1000个数            Callable<Long> task = new Callable<Long>() {                @Override                public Long call() throws Exception {                    long sum = 0;                    int r = (left + 1000) < right ? (left + 1000) : right;                    for (int i = left; i < r; i++) {                        sum += i;                    }                    return sum;                }            };            tasks.add(task);            min += 1000;        }        //使用CompletionService执行任务        CompletionService<Long> completionService = AsyncEngine.completionExecute(tasks);        long sum = 0;        for ( int i = 0; i < tasks.size(); i++) {            try {                sum += completionService.take().get();            } catch (InterruptedException e) {                e.printStackTrace();            } catch (ExecutionException e) {                e.printStackTrace();            }        }        return sum;    }}

这个类和前面那个Sum类非常类似，这里只是将任务提交给了CompletionService执行，主线程通过CompletionService的take方法取任务的Future，将任务的返回值累加并返回。