线程池详解

一.线程池简介
1.为什么要用线程池
（1）减少资源的开销 。减少了每次创建线程、销毁线程的开销。
（2）提高响应速度 ,每次请求到来时，由于线程的创建已经完成，故可以直接执行任务，因此提高了响应速度。
（3）提高线程的可管理性 ,线程是一种稀缺资源，若不加以限制，不仅会占用大量资源，而且会影响系统的稳定性。 因此，线程池可以对线程的创建与停止、线程数量等等因素加以控制，使得线程在一种可控的范围内运行，不仅能保证系统稳定运行，而且方便性能调优。
示例：

web 项目为例：
每次过来一个请求，都要在服务端创建一个新线程来处理请求，请求处理完成销毁线程。如果我们在服务端不使用线程池，而是无节制的来一个请求创建一个线程，系统资源将会很快被耗尽。而使用线程池的话，则可以防止这种情况发生。

2.Exector接口
（1）Executor两级调度模型

在HotSpot虚拟机中，Java中的线程将会被一一映射为操作系统的线程 在Java虚拟机层面，用户将多个任务提交给Executor框架,Executor负责分配线程执行它们； 在操作系统层面，操作系统再将这些线程分配给处理器执行

（2）Executor结构

Executor框架中的所有类可以分成三类：

任务
任务有两种类型：Runnable和Callable。
任务执行器
Executor框架最核心的接口是Executor，它表示任务的执行器。
Executor的子接口为ExecutorService。
ExecutorService有两大实现类：ThreadPoolExecutor和ScheduledThreadPoolExecutor。
执行结果
Future接口表示异步的执行结果，它的实现类为FutureTask。

3.线程池的处理流程
一个线程从被提交（submit）到执行共经历以下流程：

线程池判断核心线程池里是的线程是否都在执行任务，如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下一个流程
线程池判断工作队列是否已满。如果工作队列没有满，则将新提交的任务储存在这个工作队列里。如果工作队列满了，则进入下一个流程。
线程池判断其内部线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已满了，则交给饱和策略来处理这个任务。
线程池在执行execute方法时,主要有以下四种情况

如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（需要获得全局锁）
如果运行的线程等于或多于corePoolSize ,则将任务加入BlockingQueue
如果无法将任务加入BlockingQueue(队列已满)，则创建新的线程来处理任务（需要获得全局锁）
如果创建新线程将使当前运行的线程超出maxiumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。
线程池采取上述的流程进行设计是为了减少获取全局锁的次数。在线程池完成预热（当前运行的线程数大于或等于corePoolSize）之后，几乎所有的excute方法调用都执行步骤2。

4.线程池的创建说明

（1） int corePoolSize：该线程池中核心线程数最大值
核心线程：线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。
如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉。

（2）int maximumPoolSize： 该线程池中线程总数最大值
线程总数 = 核心线程数 + 非核心线程数。

（3）long keepAliveTime：该线程池中非核心线程闲置超时时长
一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉，如果设置allowCoreThreadTimeOut = true，则会作用于核心线程。

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

（4）BlockingQueue workQueue：该线程池中的任务队列：维护着等待执行的Runnable对象
当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务。
常用的workQueue类型：
1)SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大

2)LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize

3)ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误

3)DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

(4)ThreadFactory threadFactory：创建线程的方式，这是一个接口，你new他的时候需要实现他的Thread newThread(Runnable r)方法，

(5)RejectedExecutionHandler handler： 当提交任务数超过maxmumPoolSize+workQueue之和时，任务会交给RejectedExecutionHandler来处理;jdk1.5提供了四种饱和策略 ：
AbortPolicy
默认。直接抛异常。
CallerRunsPolicy
只用调用者所在的线程执行任务,重试添加当前的任务，它会自动重复调用execute()方法
DiscardOldestPolicy
丢弃任务队列中最久的任务。
DiscardPolicy
丢弃当前任务。

(6)提交任务
可以向ThreadPoolExecutor提交两种任务：Callable和Runnable。

1. Callable
   该类任务有返回结果，可以抛出异常。
   通过submit函数提交，返回Future对象。
   可通过get获取执行结果。
   2)Runnable
   该类任务只执行，无法获取返回结果，并在执行过程中无法抛异常。
   通过execute提交。

我们可以使用execute提交的任务，但是execute方法没有返回值，所以无法判断任务知否被线程池执行成功。通过以下代码可知execute方法输入的任务是一个Runnable类的实例。
threadsPool.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
});
我们也可以使用submit 方法来提交任务，它会返回一个future,那么我们可以通过这个future来判断任务是否执行成功，通过future的get方法来获取返回值，get方法会阻塞住直到任务完成，而使用get(long timeout, TimeUnit unit)方法则会阻塞一段时间后立即返回，这时有可能任务没有执行完。
try {
Object s = future.get();
} catch (InterruptedException e) {
// 处理中断异常
} catch (ExecutionException e) {
// 处理无法执行任务异常
} finally {
// 关闭线程池
executor.shutdown();
}

(7) 线程池的关闭

我们可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池，但是它们的实现原理不同，shutdown的原理是只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。shutdownNow的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。shutdownNow会首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表。

只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于我们应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow。

（8）线程池的合理配置
合理的配置线程池
要想合理的配置线程池，就必须首先分析任务特性，可以从以下几个角度来进行分析：

1)任务的性质：CPU密集型任务，IO密集型任务和混合型任务。
2)任务的优先级：高，中和低。
3)任务的执行时间：长，中和短。
4)任务的依赖性：是否依赖其他系统资源，如数据库连接。

任务性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务配置尽可能少的线程数量，如配置Ncpu+1个线程的线程池。IO密集型任务则由于需要等待IO操作，线程并不是一直在执行任务，则配置尽可能多的线程，如2*Ncpu。混合型的任务，如果可以拆分，则将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐率要高于串行执行的吞吐率，如果这两个任务执行时间相差太大，则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。

优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先得到执行，需要注意的是如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。

执行时间不同的任务可以交给不同规模的线程池来处理，或者也可以使用优先级队列，让执行时间短的任务先执行。

依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，如果等待的时间越长CPU空闲时间就越长，那么线程数应该设置越大，这样才能更好的利用CPU。

建议使用有界队列，有界队列能增加系统的稳定性和预警能力，可以根据需要设大一点，比如几千。有一次我们组使用的后台任务线程池的队列和线程池全满了，不断的抛出抛弃任务的异常，通过排查发现是数据库出现了问题，导致执行SQL变得非常缓慢，因为后台任务线程池里的任务全是需要向数据库查询和插入数据的，所以导致线程池里的工作线程全部阻塞住，任务积压在线程池里。如果当时我们设置成无界队列，线程池的队列就会越来越多，有可能会撑满内存，导致整个系统不可用，而不只是后台任务出现问题。当然我们的系统所有的任务是用的单独的服务器部署的，而我们使用不同规模的线程池跑不同类型的任务，但是出现这样问题时也会影响到其他任务。

(9)线程池的监控
通过线程池提供的参数进行监控。线程池里有一些属性在监控线程池的时候可以使用：

1）taskCount：线程池需要执行的任务数量。
2）completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount。
3）largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。
4）getPoolSize:线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不减。
5）getActiveCount：获取活动的线程数。
通过扩展线程池进行监控。通过继承线程池并重写线程池的beforeExecute，afterExecute和terminated方法，我们可以在任务执行前，执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如：
protected void beforeExecute(Thread t, Runnable r) { }

总结：

1、用ThreadPoolExecutor自定义线程池，看线程是的用途，如果任务量不大，可以用无界队列，如果任务量非常大，要用有界队列，防止OOM
2、如果任务量很大，还要求每个任务都处理成功，要对提交的任务进行阻塞提交，重写拒绝机制，改为阻塞提交。保证不抛弃一个任务
3、最大线程数一般设为2N+1最好，N是CPU核数
4、核心线程数，看应用，如果是任务，一天跑一次，设置为0，合适，因为跑完就停掉了，如果是常用线程池，看任务量，是保留一个核心还是几个核心线程数
5、如果要获取任务执行结果，用CompletionService，但是注意，获取任务的结果的要重新开一个线程获取，如果在主线程获取，就要等任务都提交后才获取，就会阻塞大量任务结果，队列过大OOM，所以最好异步开个线程获取结果

5.线程池原理
（1）线程池使用要点

在大名鼎鼎的 J.U.C 包下已经提供了 Executors
类，它已经封装实现了四种创建线程池的方式，它暴露出几个简单的方法供开发者调用。最终都是通过 new ThreadPoolExecutor()
ExecutorService
实例，从而得到我们想要的线程池类型。这样做其实有利有弊，好的是我们不用关心那么多参数，只需要简单的指定一两个参数就可以；不好的是，这样一来又屏蔽了很多细节，如果有些参数使用默认的，而开发者又不了解原理的情况下，可能会造成
OOM 等问题。

很多公司都不建议或者强制不允许直接使用 Executors
类提供的方法来创建线程池，例如阿里巴巴Java开发手册里就明确不允许这样创建线程池，一定要通过
ThreadPoolExecutor(xx,xx,xx…) 来明确线程池的运行规则，指定更合理的参数。

5.2具体说明

1.newFixedThreadPool

它有两个重载方法，代码如下：

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

建立一个线程数量固定的线程池，规定的最大线程数量，超过这个数量之后进来的任务，会放到等待队列中，如果有空闲线程，则在等待队列中获取，遵循先进先出原则。

创建固定线程数量线程池， corePoolSize 和 maximumPoolSize要一致，即核心线程数和最大线程数（核心+非核心线程）一致，Executors 默认使用的LinkedBlockingQueue作为等待队列，这是一个无界队列，这也是使用它的风险所在，除非你能保证提交的任务不会无节制的增长，否则不要使用无界队列，这样有可能造成等待队列无限增加，造成OOM。

正确的创建固定线程数线程池的做法是

private static ThreadFactory threadFactory = new
> ThreadFactoryBuilder().setNameFormat("fengzheng" +
> "-%d").setDaemon(true).build();
> 
> public static ExecutorService createFixedThreadPool() {
>         int poolSize = 5;
>         int queueSize = 10;
>         ExecutorService executorService = new ThreadPoolExecutor(poolSize, poolSize, 0L, TimeUnit.SECONDS,
>                 new ArrayBlockingQueue<Runnable>(queueSize), threadFactory, new ThreadPoolExecutor.AbortPolicy());
>         return executorService;
>     }

上面代码是创建一个 5 个线程的固定数量线程池，这里线程存活时间没有作用，所以设置为 0，使用了 ArrayBlockingQueue 作为等待队列，设置长度为 10 ，最多允许10个等待任务，超过的任务会执行默认的 AbortPolicy 策略，也就是直接抛异常ThreadFactory 使用了 Guava库提供的方法，定义了线程名称，方便之后排查问题。

2.newSingleThreadExecutor

建立一个只有一个线程的线程池，如果有超过一个任务进来，只有一个可以执行，其余的都会放到等待队列中，如果有空闲线程，则在等待队列中获取，遵循先进先出原则。使用LinkedBlockingQueue 作为等待队列。

这个方法同样存在等待队列无限长的问题，容易造成 OOM，所以正确的创建方式参考上面固定数量线程池创建的方式，只是把 poolSize 设置为1 。

3、newCachedThreadPool

缓存型线程池，在核心线程达到最大值之前，有任务进来就会创建新的核心线程，并加入核心线程池，即时有空闲的线程，也不会复用。达到最大核心线程数后，新任务进来，如果有空闲线程，则直接拿来使用，如果没有空闲线程，则新建临时线程。并且线程的允许空闲时间都很短，如果超过空闲时间没有活动，则销毁临时线程。关键点就在于它使用SynchronousQueue作为等待队列，它不会保留任务，新任务进来后，直接创建临时线程处理，这样一来，也就容易造成无限制的创建线程，造成 OOM。

正确的创建缓存型线程池的做法是

 private static ThreadFactory threadFactory = new
> ThreadFactoryBuilder().setNameFormat("fengzheng" +
> "-%d").setDaemon(true).build();
> 
>     public static ExecutorService createCacheThreadPool(){
>         int coreSize = 10;
>         int maxSize = 20;
>         return new ThreadPoolExecutor(coreSize, maxSize, 10L, TimeUnit.SECONDS,
>                 new SynchronousQueue<Runnable>(), threadFactory, new ThreadPoolExecutor.AbortPolicy());
>     }

4、newScheduledThreadPool
>

计划型线程池，可以设置固定时间的延时或者定期执行任务，同样是看线程池中有没有空闲线程，如果有，直接拿来使用，如果没有，则新建线程加入池。使用的是
DelayedWorkQueue 作为等待队列，这中类型的队列会保证只有到了指定的延时时间，才会执行任务。

正确的创建缓存型线程池的做法是

private static ThreadFactory threadFactory = new
> ThreadFactoryBuilder().setNameFormat("fengzheng" +
> "-%d").setDaemon(true).build();
> 
>     private static CountDownLatch latch = new CountDownLatch(1);
> 
>     public static void main(String[] args) throws InterruptedException {
>         Task task = new Task();
>         ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(2, threadFactory);
>         executorService.scheduleAtFixedRate(task,0L,5L, TimeUnit.SECONDS);
>         latch.await();
>     }
> 
>     static class Task implements Runnable{
>         @Override
>         public void run() {
>             System.out.println(Thread.currentThread().getName() + "executing");
>         }
>     }

附：另一篇佳文https://blog.csdn.net/u011531613/article/details/61921473