参考：https://www.cnblogs.com/dolphin0520/p/3932921.html

做下总结：

java线程池的主要类是ThreadPoolExecutor

在这里插入图片描述

此类是java线程池的核心类，后面介绍的四种线程池基本是此类的不同构造
先来看下它的构造方法：
在这里插入图片描述

     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
     BlockingQueue<Runnable> workQueue);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
     BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);

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

实际上前三种构造方法都是第四种的参数简化重载，主要是配置类一些的成员变量

下面解释下一下构造器中各个参数的含义：

corePoolSize

核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；

maximumPoolSize

线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；

keepAliveTime

表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

unit

参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒

workQueue

一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
1）ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；
2）LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
3）synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
4）DelayedWorkQueue：

ArrayBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

threadFactory

线程工厂，默认是DefaultThreadFactory，主要用来创建线程；

handler

：表示当拒绝处理任务时的策略，有以下四种取值（默认是AbortPolicy）：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

基本要配置的也就是corePoolSize，maximumPoolSize，unit，keepAliveTime，workQueue这五个参数，也就是使用第一种构造函数就可以了，后面两个参数一般选择默认就可以；

然而，java doc甚至第一种构造函数也不希望你直接手动配置使用，所以便有了以下四种java线程池，这四种线程池就是官方给你定制好参数的ThreadPoolExecutor，基本是使用上述的第一种构造函数，也就是给你配置好corePoolSize，maximumPoolSize，unit，keepAliveTime，workQueue这几个参数。

四种线程池：

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，相当于一个超大的线程池，使用的SynchronousQueue，这个队列比较特殊，相当于队列大小为0，来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程，是一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

简单来说：来一个任务有空闲的线程就用空闲的线程处理，没有的就创建一个线程给你处理。

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

创建的线程池corePoolSize和maximumPoolSize值是相等的，就是传入的整型参数，它使用的LinkedBlockingQueue，队列使用默认大小Integer.MAX_VALUE。这是一个定长线程池，可控制线程最大并发数，当线程数达到corePoolSize（maximumPoolSize），不会有新的线程建立，新加入的线程会加入到队列（直到数量达到Integer.MAX_VALUE才会采取拒绝措施），等待空闲的线程处理。

简单来说：来一个任务就找空闲的线程处理，没有空闲的就放在队列里，等待有空闲的才给你处理

newScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

corePoolSize为传入的参数，maximumPoolSize是Integer.MAX_VALUE，
创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

将corePoolSize和maximumPoolSize都设置为1，也使用的LinkedBlockingQueue，队列使用默认大小Integer.MAX_VALUE；
是一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

简单来说：一个大小为1的定长线程池

线程进入到线程池的基本执行思想是：

在这里插入图片描述
（图片来自：https://www.cnblogs.com/superfj/p/7544971.html）

总结如下：

•如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；

•如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程但不会多于maximumPoolSize去执行这个任务；

•如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；

•如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被销毁，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，也就是调用了allowCoreThreadTimeOut(boolean)方法，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被销毁，直至为0。

线程池的关闭

ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()，其中：

shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务

shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

java四种线程池配置详解