并发编程学习笔记（十一、线程池）

目录：

• ThreadPoolExecutor
• ForkJoinPool
• 两者的比较

ThreadPoolExecutor

1、无返回值demo

public class ThreadTest {

    public static void main(String[] args) {
        // 核心线程池的大小
        int corePoolSize = 2;
        // 核心线程池的最大线程数
        int maxPoolSize = 4;
        // 线程最大空闲时间
        long keepAliveTime = 10;
        // 时间单位 
        TimeUnit unit = TimeUnit.SECONDS;
        // 阻塞队列 容量为2 
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
        // 线程创建工厂 
        ThreadFactory threadFactory = new NameTreadFactory();
        // 线程池拒绝策略 
        RejectedExecutionHandler handler = new MyIgnorePolicy();
        ThreadPoolExecutor executor = null;
        try {
            // 推荐的创建线程池的方式 
            // 不推荐使用现成的API创建线程池 
            executor = new ThreadPoolExecutor(corePoolSize,
                    maxPoolSize, keepAliveTime, unit,
                    workQueue, threadFactory, handler);
            // 预启动所有核心线程，提升效率 
            executor.prestartAllCoreThreads();
            // 任务数量 
            int count = 10;
            for (int i = 1; i <= count; i++) {
                RunnableTask task = new RunnableTask(String.valueOf(i));
                executor.submit(task);
            }
        }
        finally {
            assert executor != null;
            executor.shutdown();
        }

    }

    /**
     * 线程工厂
     */
    static class NameTreadFactory implements ThreadFactory {
        // 线程id
        private final AtomicInteger threadId = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable runnable) {
            Thread t = new Thread(runnable, "线程-" + threadId.getAndIncrement());
            System.out.println(t.getName() + " 已经被创建");
            return t;
        }
    }

    /**
     * 线程池拒绝策略
     */
    public static class MyIgnorePolicy implements RejectedExecutionHandler {

        @Override
        public void rejectedExecution(Runnable runnable, ThreadPoolExecutor e) {
            doLog(runnable, e);
        }

        private void doLog(Runnable runnable, ThreadPoolExecutor e) {
            // 可做日志记录等
            System.err.println(runnable.toString() + " rejected");
        }
    }

    /**
     * 线程
     */
    static class RunnableTask implements Runnable {
        private String name;

        public RunnableTask(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                System.out.println(this.toString() + " is running!");
                // 让任务执行慢点
                Thread.sleep(3000);
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "RunnableTask [name=" + name + "]";
        }
    }

}

ThreadPoolExecutor构造函数解释：参考https://blog.csdn.net/jubaoquan/article/details/79198780

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
}

corePoolSize：线程池中核心线程数的最大值。

maximumPoolSize：线程池中能拥有最多线程数。

workQueue：用于缓存任务的阻塞队列。

关系：执行线程数量未超过corePoolSize，则线程都会执行；超过后，则进入workQueue中等待执行，若队列已满，则创建新线程引入执行，但不能超过maximumPoolSize。

通俗解释：

• 如果把线程池比作一个单位的话，corePoolSize就表示正式工数量，一个线程就可以表示一个员工。
• 当我们向单位委派一项工作时，如果单位发现正式工还没招满，单位就会招满正式工来完成这项工作。
• 随着我们向这个单位委派的工作增多，即使正式工全部满了，工作还是干不完，那么单位只能按照我们新委派的工作按先后顺序将它们找个地方搁置起来，这个地方就是workQueue，等正式工完成了手上的工作，就到这里来取新的任务。
• 如果不巧，年末了，各个部门都向这个单位委派任务，导致workQueue已经没有空位置放新的任务，于是单位决定招点临时工吧（临时工：又是我！）。
• 临时工也不是想招多少就找多少，上级部门通过这个单位的maximumPoolSize确定了你这个单位的人数的最大值，换句话说最多招(maximumPoolSize – corePoolSize)个临时工。
• 当然，在线程池中，谁是正式工，谁是临时工是没有区别，完全同工同酬。

———————————————————————————————————————————————————————

keepAliveTime：表示空闲线程的存活时间；当临时线程超过keepAliveTime还是空闲状态，则会被清理调。

TimeUnitunit：表示keepAliveTime的单位。

通俗解释：

• 假设线程池这个单位已经招了些临时工，但新任务没有继续增加，所以随着每个员工忙完手头的工作，都来workQueue领取新的任务（看看这个单位的员工多自觉啊）。
• 随着各个员工齐心协力，任务越来越少，员工数没变，那么就必定有闲着没事干的员工。
• 这样的话领导不乐意啦，但是又不能轻易开除没事干的员工，因为随时可能有新任务来，于是领导想了个办法，设定了keepAliveTime，当空闲的员工在keepAliveTime这段时间还没有找到事情干，就被辞退啦，毕竟地主家也没有余粮啊！
• 当然辞退到corePoolSize个员工时就不再辞退了，领导也不想当光杆司令啊！

———————————————————————————————————————————————————————

handler：表示当workQueue已满，且池中的线程数达到maximumPoolSize时，线程池拒绝添加新任务时采取的策略。

通俗解释：

• 假设线程池这个单位招满临时工，但新任务依然继续增加，线程池从上到下，从里到外真心忙的不可开交，阻塞队列也满了，只好拒绝上级委派下来的任务。

———————————————————————————————————————————————————————

threadFactory：指定创建线程的工厂。

———————————————————————————————————————————————————————

2、有返回值demo

public class CallableTest {
    
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = null;
        int count = 10;
        try {
            // !!! 不推荐使用Executors的静态方法创建线程池 !!!
            executor = Executors.newCachedThreadPool();
            // CompletionService：执行线程、获取线程执行结果
            CompletionService<String> completionService = new ExecutorCompletionService<>(executor);
            for (int i = 0; i < count; i++) {
                FactorialCalculator factorialCalculator = new FactorialCalculator(i);
                // 放一个实现java.util.concurrent.Callable的类就行
                completionService.submit(factorialCalculator);
            }

            for (int i = 0; i < count; i++) {
                Future<String> result = completionService.take();
                System.out.print(result.get());
            }
        }
        catch (ExecutionException e) {
            e.printStackTrace();
        }
        finally {
            assert executor != null;
            executor.shutdown();
        }
    }
}

public class FactorialCalculator implements Callable<String> {

    private Integer number;

    public FactorialCalculator(Integer number) {
        this.number = number;
    }

    @Override
    public String call() throws Exception {
        int result = 1;

        if (number == 0 || number == 1) {
            result = 1;
        }
        else {
            for (int i = 2; i <= number; i++) {
                result *= i;
                TimeUnit.MICROSECONDS.sleep(200);
            }
        }
        return String.format("%s输出%d的阶乘为：%d\n",
                Thread.currentThread().getName(), number, result);
    }
}

ForkJoinPool

1、无返回demo

private static void validateFolkJoin() throws InterruptedException {
    // 需求：简单打印1-3000的数字
    // 程序将一个大任务拆分成多个小任务
    // 并将任务交给ForkJoinPool来执行
    PrintTask task = new PrintTask(0, 3000);
    //创建线程池
    ForkJoinPool pool = new ForkJoinPool();
    //将task提交至线程池
    pool.submit(task);
    //线程阻塞，等待所有任务完成
    pool.awaitTermination(2, TimeUnit.SECONDS);

    System.out.printf("RESULT_SET的大小=%s", RESULT_SET.size());
    pool.shutdown();
}

2、有返回demo

public static void main(String[] args) throws Exception {
        // 需求：对于长度为10000的元素数组进行累加
        int[] nums = new int[10000];
        Random random = new Random();
        int total = 0;
        // 初始化数组元素
        long start = System.nanoTime();
        for (int i = 0; i < nums.length; i++) {
            int temp = random.nextInt(100);
            nums[i] = temp;
            total += nums[i];
        }
        long end = System.nanoTime();
        System.out.println("初始化数组用时：" + (end - start) + "纳秒, 初始化数组总和:" + total);

        // ------------ 主要核心代码 ------------
        long startTask = System.nanoTime();
        // 创建Task
        SumTask task = new SumTask(nums, 0, nums.length);
        // 创建线程池
        ForkJoinPool pool = new ForkJoinPool();
        // 提交任务,存在返回值
        ForkJoinTask<Integer> future = pool.submit(task);
        // 显示结果
        long endTask = System.nanoTime();
        System.out.println("线程池计算用时：" + (endTask - startTask) + "纳秒, 线程池执行结果:" + future.get());
        // 关闭多线程
        pool.shutdown();
    }

两者的比较

ThreadPoolExecutor：适用于IO密集型任务（因目前市场的主流是前后端分离，所以IO密集型更为适用）

• HTTP
• RPC
• DB
• Redis
• MQ
• ZK密集型任务10亿数字文本做排序

ForkJoinPool：适用于CPU密集型任务

• 处理大量的商户信息
• 对一个10亿数字文本做排序