7、线程池使用过吗？谈谈对 ThreadPoolExector 的理解？

1、为什使用线程池，线程池的优势？

线程池用于多线程处理中，它可以根据系统的情况，可以有效控制线程执行的数量，优化运行效果。线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，那么超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

主要特点为：

• 线程复用
• 控制最大并发数量
• 管理线程

主要优点：

• 降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
• 提高相应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅仅会消耗系统资源，还会降低体统的稳定性，使用线程可以进行统一分配，调优和监控。

创建线程的几种方式：

• 继承 Thread
• 实现 Runnable 接口
• 实现 Callable

package com.example.rabbitmq.test.nio;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class callableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable，并设置返回值为 Integer
        Callable<Integer> integerCallable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 666;
            }
        };
        //Callable传入到 FutureTask
        FutureTask<Integer> integerCallableFutureTask = new FutureTask<>(integerCallable);
        //FutureTask传入线程种
        new Thread(integerCallableFutureTask,"AAA").start();
        //FutureTask获取线程返回值
        Integer integer = integerCallableFutureTask.get();
        System.out.println(integer);

    }
}

2、线程池如果使用？

架构说明：

线程池快捷实现的几种方式（不推荐！！！）：

• Executors.newSingleThreadExecutor()：只有一个线程的线程池，因此所有提交的任务是顺序执行
• Executors.newCachedThreadPool()：线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除
• Executors.newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待
• Executors.newScheduledThreadPool()：用来调度即将执行的任务的线程池
• Executors.newWorkStealingPool()： newWorkStealingPool适合使用在很耗时的操作，但是newWorkStealingPool不是ThreadPoolExecutor的扩展，它是新的线程池类ForkJoinPool的扩展，但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），所以适合使用在很耗时的任务中

ThreadPoolExecutor

• ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务

3、线程池的几个重要参数介绍？

4、说说线程池的底层工作原理？

重点讲解： 其中比较容易让人误解的是：corePoolSize，maximumPoolSize，workQueue之间关系。

5、线程池用过吗？生产上你如何设置合理参数？

线程池的拒绝策略你谈谈？

• 是什么
  等待队列已经满了，再也塞不下新的任务，同时线程池中的线程数达到了最大线程数，无法继续为新任务服务。
• 拒绝策略
  1、AbortPolicy：处理程序遭到拒绝将抛出运行时 RejectedExecutionException
  2、CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
  3、DiscardPolicy：不能执行的任务将被删除
  4、DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）

6、你在工作中单一的、固定数的和可变的三种创建线程池的方法，你用哪个多，超级大坑？

如果读者对Java中的阻塞队列有所了解的话，看到这里或许就能够明白原因了。
Java中的BlockingQueue主要有两种实现，分别是ArrayBlockingQueue 和 LinkedBlockingQueue。

ArrayBlockingQueue是一个用数组实现的有界阻塞队列，必须设置容量。

LinkedBlockingQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。

这里的问题就出在：不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。也就是说，如果我们不设置LinkedBlockingQueue的容量的话，其默认容量将会是Integer.MAX_VALUE。

而newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。

上面提到的问题主要体现在newFixedThreadPool和newSingleThreadExecutor两个工厂方法上，并不是说newCachedThreadPool和newScheduledThreadPool这两个方法就安全了，这两种方式创建的最大线程数可能是Integer.MAX_VALUE，而创建这么多线程，必然就有可能导致OOM。

7、你在工作中是如何使用线程池的，是否自定义过线程池使用？

 //定义一个线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                20, //核心线程数
                80,//最大线程数
                2,//非核心线程的存活时间
                TimeUnit.SECONDS,//时间单位
                new LinkedBlockingQueue<>(10000),//阻塞队列长度
                Executors.defaultThreadFactory(),//线程工厂，一般就是这个默认的
                new ThreadPoolExecutor.DiscardPolicy()//拒绝策略
        );

8、合理配置线程池你是如果考虑的？

• CPU 密集型

CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。

• IO 密集型

由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2 。
也可以使用公式：CPU 核数 / (1 - 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。