线程池整理-一一网

为什么要用线程池？线程池的优势是什么？

线程池主要的工作是控制运行的线程数量，处理过程中将任务放进队列里，然后在线程创建后启动这些任务，如果线程数量超过了最大数量的线程排队等候，等其他线程执行完毕，再从队列里取出任务来执行。

主要优势：线程复用、控制最大并发数、管理线程

（1）降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的损耗；

（2）提高响应速度，当任务到达时，任务可以不需要等到线程创建就可以执行；

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。

线程池是一个管理线程的池子。由于创建和关闭线程需要花费时间，如果为每一个任务都创建一个线程，非常消耗资源。使用线程池可以避免增加创建和销毁线程的资源消耗，提高响应速度，且能重复利用线程。在使用线程池后，创建线程就变成了从线程池中获取空闲线程，关闭线程变成了向线程池归还线程。

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

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

corePoolSize: 线程池中核心线程的数量，在没有用的时候，也不会被回收！

maximumPoolSize ：线程池中最大线程数量，包括核心线程池

keepAliveTime：就是线程池中除了核心线程之外的其他的最长可以保留的时间，因为在线程池中，除了核心线程即使在无任务的情况下也不能被清除，其余的都是有存活时间的，意思就是非核心线程可以保留的最长的空闲时间

TimeUnit unit：存活时间单位

workQueue：任务队列

threadFactory：线程工厂，用于创建线程，一般用默认的即可

handler：拒绝策略，当队列满了并且工作线程大于等于线程池的最大线程数

初始化线程池时可以预先创建线程吗？

prestartAllCoreThreads

初始化线程池时是可以预先创建线程的，初始化线程池后，再调用prestartAllCoreThreads()方法，即可预先创建corePoolSize数量的核心线程

public int prestartAllCoreThreads() {
    int n = 0;
    while (addWorker(null, true))
        ++n;
    return n;
}
private boolean addWorker(Runnable firstTask, boolean core) {
  // ..
}
复制代码

addWorker方法目的是在线程池中添加任务并执行，如果task为空，线程获取任务执行时调用getTask()方法，该方法从blockingQueue阻塞队列中阻塞获取任务执行，因此线程不会释放，留存在线程池中，如果core=true，说明任务只能利用核心线程来执行。

所以该方法会在线程池总预先创建没有任务执行的线程，数量为corePoolSize

prestartCoreThread

prestartCoreThread()同样可以预先创建线程，只不过该方法只会与创建1条线程

public boolean prestartCoreThread() {
    return workerCountOf(ctl.get()) < corePoolSize &&
        addWorker(null, true);
}
复制代码

如果此时工作线程数量小于corePoolSize，那么就调用addWorker创建1条空闲核心线程

线程池的核心线程可以被回收吗

allowCoreThreadTimeOut

ThreadPoolExecutor有一个私有成员变量：

private volatile boolean allowCoreThreadTimeOut;
复制代码

如果allowCoreThreadTimeOut=true，核心线程在规定时间内会被回收

线程池的执行流程

（1）在创建线程池后，等待提交过来的任务请求；

（2）当调用execute()方法添加一个请求任务时，线程池会做如下判断：

如果正在运行的线程数量小于corePoolSize，那么马上创建核心线程运行这个任务；

如果正在运行的线程数量大于或者等于corePoolSize，那么将这个任务放入任务队列中；

如果任务队列满了且正在运行的线程数量小于maximumPoolSize(最大线程数)，那么创建一个非核心线程立刻运行这个任务；

如果任务队列满了且正在运行的线程数量大于或等于maximumPoolSize，线程池会执行拒绝策略；
复制代码

（3）当一个线程完成任务时，会在队列中取下一个任务来执行；

（4）当一个线程无事可做超过一定时间时，线程池会停掉。

拒绝策略

等待的任务队列满了，容纳不下新任务，同时线程池中的最大线程数也达到了，无法创建新的非核心线程去处理任务，此时需要拒绝策略。

AbortPolicy：抛出 RejectedExecutionException异常阻止系统正常进行；

CallerRunsPolicy：将任务回退到调用者，由调用线程处理该任务。

DiscardOldestPolicy：丢弃任务队列中等待最久的任务，将当前任务放入任务队列中；

DiscardPolicy：直接丢弃任务，不处理也不抛出异常；

除了JDK默认提供的四种拒绝策略，我们可以根据自己的业务需求去自定义拒绝策略，自定义的方式很简单，直接实现RejectedExecutionHandler接口即可

线程池都有哪几种工作队列

1、ArrayBlockingQueue

是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。

2、LinkedBlockingQueue

一个基于链表结构的阻塞队列，此队列按FIFO （先进先出）排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列

3、SynchronousQueue

一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

4、PriorityBlockingQueue

一个具有优先级的无限阻塞队列。

怎么理解无界队列和有界队列

有界队列

1.初始的poolSize < corePoolSize，提交的runnable任务，会直接做为new一个Thread的参数，立马执行。

2.当提交的任务数超过了corePoolSize，会将当前的runable提交到一个block queue中。

3.有界队列满了之后，如果poolSize < maximumPoolsize时，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务。

4.如果3中也无法处理了，就会走到第四步执行reject操作。

无界队列

与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新的任务到来，系统的线程数小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加，若后续仍有新的任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存

常见的线程池种类？

newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行。

单一的、固定数、可变的三种创建线程的方法，你在工作中用到过哪个？

一般不适用这三种方法，阿里巴巴Java开发手册中说过，线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

//ExecutorService threadPool = Executors.newFixedThreadPool(5);//一池5个处理线程
//ExecutorService threadPool = Executors.newFixedThreadPool(1);//一池1个线程
ExecutorService threadPool = Executors.newCachedThreadPool();//一池N个线程
复制代码

说明：Executors返回的线程池对象的弊端如下：

FixedThreadPool和SingleThreadPool:

允许请求的队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM；
CacheThreadPool和ScheduledThreadPool:

允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM；