本文目录

1. 如何更好的使用JAVA线程池
2. 如何优雅的使用和理解线程池你怎么看
3. executor和executors的区别
4. 为什么要使用线程池

如何更好的使用JAVA线程池

线程池是为了解决线程创建资源消耗问题而出现的。所以要更好的使用线程池就要分别从线程池大小参数的设置、工作线程的创建、空闲线程的回收、阻塞队列的使用、任务拒绝策略、线程池Hook等方面来了解线程池的使用，其中涉及到一些细节包括不同参数、不同队列、不同拒绝策略的选择、产生的影响和行为、为更好的使用线程池奠定知识基础。

ExecutorService基于池化的线程来执行用户提交的任务，通常可以简单的通过Executors提供的工厂方法来创建ThreadPoolExecutor实例。

线程池解决的两个问题：

快速开始

为了使得线程池适合大量不同的应用上下文环境，ThreadPoolExecutor提供了很多可以配置的参数和可被用来扩展的钩子。然而，用户还可以通过使用Executors提供的一些工厂方法来快速创建ThreadPoolExecutor实例。比如：

如果上面的方法创建的实例不能满足我们的需求，我们可以自己通过参数来配置，实例化一个实例。

关于线程数大小参数设置

ThreadPoolExecutor会根据corePoolSize和maximumPoolSize来动态调整线程池的大小:poolSize。

当任务通过executor提交给线程池的时候，我们需要知道下面几个点：

核心线程WarmUp

默认情况下，核心工作线程值在初始的时候被创建，当新任务来到的时候被启动，但是我们可以通过重写prestartCoreThread或prestartCoreThreads方法来改变这种行为。通常场景我们可以在应用启动的时候来WarmUp核心线程，从而达到任务过来能够立马执行的结果，使得初始任务处理的时间得到一定优化。

定制工作线程的创建

新的线程是通过ThreadFactory来创建的，如果没有指定，默认的Executors#defaultThreadFactory将被使用，这个时候创建的线程将都属于同一个线程组，拥有同样的优先级和daemon状态。扩展配置ThreadFactory，我们可以配置线程的名字、线程组合daemon状态。如果调用ThreadFactory#createThread的时候失败，将返回null，executor将不会执行任何任务。

空闲线程回收

如果当前池子中的工作线程数大于corePoolSize，如果超过这个数字的线程处于空闲的时间大于keepAliveTime，则这些线程将会被终止，这是一种减少不必要资源消耗的策略。这个参数可以在运行时被改变，我们同样可以将这种策略应用给核心线程，我们可以通过调用allowCoreThreadTimeout来实现。

选择合适的阻塞队列

所有的阻塞队列都可以被用来存放任务，但是使用不同的队列针对corePoolSize会表现不同的行为：

1、当池中工作线程数小于corePoolSize的时候，每次来任务的时候都会创建一个新的工作线程。

2、当池中工作线程数大于等于corePoolSize的时候，每次任务来的时候都会首先尝试将线程放入队列，而不是直接去创建线程。

3、如果放入队列失败，且当先池中线程数小于maximumPoolSize的时候，则会创建一个工作线程。

下面主要是不同队列策略表现:

1、直接递交：一种比较好的默认选择是使用SynchronousQueue，这种策略会将提交的任务直接传送给工作线程，而不持有。如果当前没有工作线程来处理，即任务放入队列失败，则根据线程池的实现，会引发新的工作线程创建，因此新提交的任务会被处理。这种策略在当提交的一批任务之间有依赖关系的时候避免了锁竞争消耗。值得一提的是，这种策略最好是配合unbounded线程数来使用，从而避免任务被拒绝。同时我们必须要考虑到一种场景，当任务到来的速度大于任务处理的速度，将会引起无限制的线程数不断的增加。

2、无界队列：使用无界队列如LinkedBlockingQueue没有指定最大容量的时候，将会引起当核心线程都在忙的时候，新的任务被放在队列上，因此，永远不会有大于corePoolSize的线程被创建，因此maximumPoolSize参数将失效。这种策略比较适合所有的任务都不相互依赖，独立执行。举个例子，如网页服务器中，每个线程独立处理请求。但是当任务处理速度小于任务进入速度的时候会引起队列的无限膨胀。

3、有界队列：有界队列如ArrayBlockingQueue帮助限制资源的消耗，但是不容易控制。队列长度和maximumPoolSize这两个值会相互影响，使用大的队列和小maximumPoolSize会减少CPU的使用、操作系统资源、上下文切换的消耗，但是会降低吞吐量，如果任务被频繁的阻塞如IO线程，系统其实可以调度更多的线程。使用小的队列通常需要大maximumPoolSize，从而使得CPU更忙一些，但是又会增加降低吞吐量的线程调度的消耗。总结一下是IO密集型可以考虑多些线程来平衡CPU的使用，CPU密集型可以考虑少些线程减少线程调度的消耗。

选择适合的拒绝策略

当新的任务到来的而线程池被关闭的时候，或线程数和队列已经达到上限的时候，我们需要去做一个决定，怎么拒绝这些任务。下面介绍一下常用的策略：

1、ThreadPoolExecutor#AbortPolicy：这个策略直接抛出RejectedExecutionException异常。

2、ThreadPoolExecutor#CallerRunsPolicy：这个策略将会使用Caller线程来执行这个任务，这是一种feedback策略，可以降低任务提交的速度。

3、ThreadPoolExecutor#DiscardPolicy：这个策略将会直接丢弃任务。

4、ThreadPoolExecutor#DiscardOldestPolicy：这个策略将会把任务队列头部的任务丢弃，然后重新尝试执行，如果还是失败则继续实施策略。

除了上面的几种策略，我们也可以通过实现RejectedExecutionHandler来实现自己的策略。

利用Hook嵌入你的行为

ThreadPoolExecutor提供了protected类型可以被覆盖的钩子方法，允许用户在任务执行之前会执行之后做一些事情。我们可以通过它来实现比如初始化ThreadLocal、收集统计信息、如记录日志等操作。这类Hook如beforeExecute和afterExecute。另外还有一个Hook可以用来在任务被执行完的时候让用户插入逻辑，如rerminated。

如果hook方法执行失败，则内部的工作线程的执行将会失败或被中断。

可访问的队列

getQueue方法可以用来访问queue队列以进行一些统计或者debug工作，我们不建议用作其他用途。同时remove方法和purge方法可以用来将任务从队列中移除。

关闭线程池

当线程池不在被引用并且工作线程数为0的时候，线程池将被终止。我们也可以调用shutdown来手动终止线程池。如果我们忘记调用shutdown，为了让线程资源被释放，我们还可以使用keepAliveTime和allowCoreThreadTimeOut来达到目的。

我们在写程序时要注意自己的应用场景，根据场景使用合适的策略和参数才是正确的打开方式，有问题可以私信我。欢迎交流！

如何优雅的使用和理解线程池你怎么看

提示

请带着这些问题继续后文，会很大程度上帮助你更好的理解相关知识点。@pdai

线程池能够对线程进行统一分配，调优和监控:

Java是如何实现和管理线程池的?

从JDK5开始，把工作单元与执行机制分离开来，工作单元包括Runnable和Callable，而执行机制由Executor框架提供。

SimpleThreadPool

程序中我们创建了固定大小为五个工作线程的线程池。然后分配给线程池十个工作，因为线程池大小为五，它将启动五个工作线程先处理五个工作，其他的工作则处于等待状态，一旦有工作完成，空闲下来工作线程就会捡取等待队列里的其他工作进行执行。

这里是以上程序的输出。

输出表明线程池中至始至终只有五个名为"pool-1-thread-1"到"pool-1-thread-5"的五个线程，这五个线程不随着工作的完成而消亡，会一直存在，并负责执行分配给线程池的任务，直到线程池消亡。

Executors类提供了使用了ThreadPoolExecutor的简单的ExecutorService实现，但是ThreadPoolExecutor提供的功能远不止于此。我们可以在创建ThreadPoolExecutor实例时指定活动线程的数量，我们也可以限制线程池的大小并且创建我们自己的RejectedExecutionHandler实现来处理不能适应工作队列的工作。

这里是我们自定义的RejectedExecutionHandler接口的实现。

ThreadPoolExecutor提供了一些方法，我们可以使用这些方法来查询executor的当前状态，线程池大小，活动线程数量以及任务数量。因此我是用来一个监控线程在特定的时间间隔内打印executor信息。

这里是使用ThreadPoolExecutor的线程池实现例子。

注意在初始化ThreadPoolExecutor时，我们保持初始池大小为2，最大池大小为4而工作队列大小为2。因此如果已经有四个正在执行的任务而此时分配来更多任务的话，工作队列将仅仅保留他们(新任务)中的两个，其他的将会被RejectedExecutionHandlerImpl处理。

上面程序的输出可以证实以上观点。

注意executor的活动任务、完成任务以及所有完成任务，这些数量上的变化。我们可以调用shutdown()方法来结束所有提交的任务并终止线程池。

其实java线程池的实现原理很简单，说白了就是一个线程集合workerSet和一个阻塞队列workQueue。当用户向线程池提交一个任务(也就是线程)时，线程池会先将任务放入workQueue中。workerSet中的线程会不断的从workQueue中获取线程然后执行。当workQueue中没有任务的时候，worker就会阻塞，直到队列中有任务了就取出来继续执行。

当一个任务提交至线程池之后:

当ThreadPoolExecutor创建新线程时，通过CAS来更新线程池的状态ctl.

LinkedBlockingQueue比ArrayBlockingQueue在插入删除节点性能方面更优，但是二者在put(),take()任务的时均需要加锁，SynchronousQueue使用无锁算法，根据节点的状态判断执行，而不需要用到锁，其核心是Transfer.transfer().

当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。

线程池的线程数量达corePoolSize后，即使线程池没有可执行任务时，也不会释放线程。

FixedThreadPool的工作队列为无界队列LinkedBlockingQueue(队列容量为Integer.MAX_VALUE),这会导致以下问题:

初始化的线程池中只有一个线程，如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行.

由于使用了无界队列,所以SingleThreadPool永远不会拒绝,即饱和策略失效

线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；和newFixedThreadPool创建的线程池不同，newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；执行过程与前两种稍微不同:

遍历线程池中的所有线程，然后逐个调用线程的interrupt方法来中断线程.

将线程池里的线程状态设置成SHUTDOWN状态,然后中断所有没有正在执行任务的线程.

将线程池里的线程状态设置成STOP状态,然后停止所有正在执行或暂停任务的线程.只要调用这两个关闭方法中的任意一个,isShutDown()返回true.当所有任务都成功关闭了,isTerminated()返回true.

其中AtomicInteger变量ctl的功能非常强大:利用低29位表示线程池中线程数，通过高3位表示线程池的运行状态:

execute–>addWorker–>runworker(getTask)

线程池的工作线程通过Woker类实现，在ReentrantLock锁的保证下，把Woker实例插入到HashSet后，并启动Woker中的线程。从Woker类的构造方法实现可以发现:线程工厂在创建线程thread时，将Woker实例本身this作为参数传入，当执行start方法启动线程thread时，本质是执行了Worker的runWorker方法。firstTask执行完成之后，通过getTask方法从阻塞队列中获取等待的任务，如果队列中没有任务，getTask方法会被阻塞并挂起，不会占用cpu资源；

ThreadPoolExecutor.execute(task)实现了Executor.execute(task)

在多线程环境下，线程池的状态时刻在变化，而ctl.get()是非原子操作，很有可能刚获取了线程池状态后线程池状态就改变了。判断是否将command加入workque是线程池之前的状态。倘若没有doublecheck，万一线程池处于非running状态(在多线程环境下很有可能发生)，那么command永远不会执行。

从方法execute的实现可以看出:addWorker主要负责创建新的线程并执行任务线程池创建新线程执行任务时，需要获取全局锁:

一些属性还有构造方法:

runWorker方法是线程池的核心:

通过getTask方法从阻塞队列中获取等待的任务，如果队列中没有任务，getTask方法会被阻塞并挂起，不会占用cpu资源；

getTask方法

下面来看一下getTask()方法，这里面涉及到keepAliveTime的使用，从这个方法我们可以看出线程池是怎么让超过corePoolSize的那部分worker销毁的。

注意这里一段代码是keepAliveTime起作用的关键:

allowCoreThreadTimeOut为false，线程即使空闲也不会被销毁；倘若为ture，在keepAliveTime内仍空闲则会被销毁。

如果线程允许空闲等待而不被销毁timed==false，workQueue.take任务:如果阻塞队列为空，当前线程会被挂起等待；当队列中有任务加入时，线程被唤醒，take方法返回任务，并执行；

如果线程不允许无休止空闲timed==true,workQueue.poll任务:如果在keepAliveTime时间内，阻塞队列还是没有任务，则返回null；

在实际业务场景中，Future和Callable基本是成对出现的，Callable负责产生结果，Future负责获取结果。

AbstractExecutorService.submit()实现了ExecutorService.submit()可以获取执行完的返回值,而ThreadPoolExecutor是AbstractExecutorService.submit()的子类，所以submit方法也是ThreadPoolExecutor`的方法。

通过submit方法提交的Callable任务会被封装成了一个FutureTask对象。通过Executor.execute方法提交FutureTask到线程池中等待被执行，最终执行的是FutureTask的run方法；

publicclassFutureTask<V>implementsRunnableFuture<V>可以将FutureTask提交至线程池中等待被执行(通过FutureTask的run方法来执行)

内部状态的修改通过sun.misc.Unsafe修改

内部通过awaitDone方法对主线程进行阻塞，具体实现如下:

如果主线程被中断，则抛出中断异常；

run方法

FutureTask.run方法是在线程池中被执行的，而非主线程

shutdown方法会将线程池的状态设置为SHUTDOWN,线程池进入这个状态后,就拒绝再接受任务,然后会将剩余的任务全部执行完

shutdownNow做的比较绝，它先将线程池状态设置为STOP，然后拒绝所有提交的任务。最后中断左右正在运行中的worker,然后清空任务队列。

更深入理解

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors各个方法的弊端：

首先引入：commons-lang3包

首先引入：com.google.guava包

spring配置线程池方式：自定义线程工厂bean需要实现ThreadFactory，可参考该接口的其它默认实现类，使用方式直接注入bean调用execute(Runnabletask)方法即可

配置线程池需要考虑因素

从任务的优先级，任务的执行时间长短，任务的性质(CPU密集/IO密集)，任务的依赖关系这四个角度来分析。并且近可能地使用有界的工作队列。

性质不同的任务可用使用不同规模的线程池分开处理:

可以使用ThreadPoolExecutor以下方法:

由于问答代码块插入受限，部分代码未完全展示，若有需要可阅读原文：戳我阅读原文

executor和executors的区别

1.Executor它是"执行者"接口，它是来执行任务的。准确的说，Executor提供了execute()接口来执行已提交的Runnable任务的对象。

Executor存在的目的是提供一种将"任务提交"与"任务如何运行"分离开来的机制。它只包含一个函数接口。2.ExecutorsExecutors是个静态工厂类。它通过静态工厂方法返回ExecutorService、ScheduledExecutorService、ThreadFactory和Callable等类的对象。

为什么要使用线程池

1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

关于本次executor和executors的区别和executorservice不建议使用的问题分享到这里就结束了，如果解决了您的问题，我们非常高兴。