Java线程池

Java线程池使用说明

一简介

线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。

二：线程池

线程池的作用：
线程池作用就是限制系统中执行线程的数量。

根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。
为什么要用线程池:
1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
比较重要的几个类：

ExecutorService	真正的线程池接口。
ScheduledExecutorService	能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。
ThreadPoolExecutor	ExecutorService的默认实现。
ScheduledThreadPoolExecutor	继承ThreadPoolExecutor的ScheduledExecutorS 4000 ervice接口实现，周期性任务调度的类实现。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。
1.newSingleThreadExecutor
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
2.newFixedThreadPool
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
3.newCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
4.newScheduledThreadPool
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
实例
1：newSingleThreadExecutor
MyThread.java

publicclassMyThreadextendsThread { @Override publicvoidrun() { System.out.println(Thread.currentThread().getName() +"正在执行。。。"); } }

TestSingleThreadExecutor.java

publicclassTestSingleThreadExecutor{ publicstaticvoidmain(String[] args){ //创建一个可重用固定线程数的线程池 ExecutorServicepool=Executors.newSingleThreadExecutor(); //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 Threadt1=newMyThread(); Threadt2=newMyThread(); Threadt3=newMyThread(); Threadt4=newMyThread(); Threadt5=newMyThread(); //将线程放入池中进行执行 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); //关闭线程池 pool.shutdown(); } }

输出结果

pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-1正在执行。。。

2newFixedThreadPool
TestFixedThreadPool.Java

publicclassTestFixedThreadPool { publicstaticvoidmain(String[] args){ //创建一个可重用固定线程数的线程池 ExecutorServicepool=Executors.newFixedThreadPool(2); //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 Threadt1=newMyThread(); Threadt2=newMyThread(); Threadt3=newMyThread(); Threadt4=newMyThread(); Threadt5=newMyThread(); //将线程放入池中进行执行 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); //关闭线程池 pool.shutdown(); } }

输出结果

pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-2正在执行。。。 pool-1-thread-1正在执行。。。

3newCachedThreadPool
TestCachedThreadPool.java

publicclassTestCachedThreadPool { publicstaticvoidmain(String[] args){ //创建一个可重用固定线程数的线程池 ExecutorServicepool=Executors.newCachedThreadPool(); //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口 Threadt1=newMyThread(); Threadt2=newMyThread(); Threadt3=newMyThread(); Threadt4=newMyThread(); Threadt5=newMyThread(); //将线程放入池中进行执行 pool.execute(t1); pool.execute(t2); pool.execute(t3); pool.execute(t4); pool.execute(t5); //关闭线程池 pool.shutdown(); } }

输出结果：

pool-1-thread-2正在执行。。。 pool-1-thread-4正在执行。。。 pool-1-thread-3正在执行。。。 pool-1-thread-1正在执行。。。 pool-1-thread-5正在执行。。。

4newScheduledThreadPool
TestScheduledThreadPoolExecutor.java

publicclassTestScheduledThreadPoolExecutor { publicstaticvoidmain(String[] args){ ScheduledThreadPoolExecutorexec=newScheduledThreadPoolExecutor(1); exec.scheduleAtFixedRate(newRunnable() {//每隔一段时间就触发异常 @Override publicvoidrun() { //thrownewRuntimeException(); System.out.println("================"); } },1000,5000,TimeUnit.MILLISECONDS); exec.scheduleAtFixedRate(newRunnable() {//每隔一段时间打印系统时间，证明两者是互不影响的 @Override publicvoidrun() { System.out.println(System.nanoTime()); } },1000,2000,TimeUnit.MILLISECONDS); } }

输出结果

================ 8384644549516 8386643829034 8388643830710 ================ 8390643851383 8392643879319 8400643939383

三：ThreadPoolExecutor详解

ThreadPoolExecutor的完整构造方法的签名是：ThreadPoolExecutor

(intcorePoolSize,
intmaximumPoolSize,longkeepAliveTime,TimeUnitunit,BlockingQueue<Runnable>workQueue,ThreadFactorythreadFactory,RejectedExecutionHandlerhandler)

.
corePoolSize-池中所保存的线程数，包括空闲线程。
maximumPoolSize-池中允许的最大线程数。
keepAliveTime-当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit-keepAliveTime参数的时间单位。
workQueue-执行前用于保持任务的队列。此队列仅保持由execute方法提交的Runnable任务。
threadFactory-执行程序创建新线程时使用的工厂。
handler-由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
ThreadPoolExecutor是Executors类的底层实现。
在JDK帮助文档中，有如此一段话：
“强烈建议程序员使用较为方便的

Executors

工厂方法

Executors.newCachedThreadPool()

（无界线程池，可以进行自动线程回收）、

Executors.newFixedThreadPool(int)

（固定大小线程池）

Executors.newSingleThreadExecutor()

（单个后台线程）
它们均为大多数使用场景预定义了设置。”
下面介绍一下几个类的源码：
ExecutorServicenewFixedThreadPool(intnThreads):固定大小线程池。
可以看到，corePoolSize和maximumPoolSize的大小是一样的（实际上，后面会介绍，如果使用无界queue的话maximumPoolSize参数是没有意义的），keepAliveTime和unit的设值表名什么？-就是该实现不想keep
alive！最后的BlockingQueue选择了LinkedBlockingQueue，该queue有一个特点，他是无界的。

1.publicstaticExecutorServicenewFixedThreadPool(intnThreads){ 2.returnnewThreadPoolExecutor(nThreads,nThreads, 3.0L,TimeUnit.MILLISECONDS, 4.newLinkedBlockingQueue<Runnable>()); 5.}

ExecutorServicenewSingleThreadExecutor()：单线程

1.publicstaticExecutorServicenewSingleThreadExecutor(){ 2.returnnewFinalizableDelegatedExecutorService 3.(newThreadPoolExecutor(1,1, 4.0L,TimeUnit.MILLISECONDS, 5.newLinkedBlockingQueue<Runnable>())); 6.}

ExecutorServicenewCachedThreadPool()：无界线程池，可以进行自动线程回收
这个实现就有意思了。首先是无界的线程池，所以我们可以发现maximumPoolSize为big
big。其次BlockingQueue的选择上使用SynchronousQueue。可能对于该BlockingQueue有些陌生，简单说：该QUEUE中，每个插入操作必须等待另一个线程的对应移除操作。

1.publicstaticExecutorServicenewCachedThreadPool(){ 2.returnnewThreadPoolExecutor(0,Integer.MAX_VALUE, 3.60L,TimeUnit.SECONDS, 4.newSynchronousQueue<Runnable>()); }

先从BlockingQueue<Runnable>workQueue这个入参开始说起。在JDK中，其实已经说得很清楚了，一共有三种类型的queue。
所有BlockingQueue都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：
如果运行的线程少于corePoolSize，则Executor始终首选添加新的线程，而不进行排队。（如果当前运行的线程小于corePoolSize，则任务根本不会存放，添加到queue中，而是直接抄家伙（thread）开始运行）
如果运行的线程等于或多于corePoolSize，则Executor始终首选将请求加入队列，而不添加新的线程。
如果无法将请求加入队列，则创建新的线程，除非创建此线程超出maximumPoolSize，在这种情况下，任务将被拒绝。
queue上的三种类型。

排队有三种通用策略：
直接提交。工作队列的默认选项是SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界maximumPoolSizes以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
无界队列。使用无界队列（例如，不具有预定义容量的LinkedBlockingQueue）将导致在所有corePoolSize线程都忙时新任务在队列中等待。这样，创建的线程就不会超过corePoolSize。（因此，maximumPoolSize的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在Web页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
有界队列。当使用有限的maximumPoolSizes时，有界队列（如ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低CPU使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是I/O边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。
BlockingQueue的选择。
例子一：使用直接提交策略，也即SynchronousQueue。
首先SynchronousQueue是无界的，也就是说他存数任务的能力是没有限制的，但是由于该Queue本身的特性，在某次添加元素后必须等待其他线程取走后才能继续添加。在这里不是核心线程便是新创建的线程，但是我们试想一样下，下面的场景。
我们使用一下参数构造ThreadPoolExecutor：
1.newThreadPoolExecutor(

2.2,3,30,TimeUnit.SECONDS,

3.new
SynchronousQueue<Runnable>(),
4.newRecorderThreadFactory("CookieRecorderPool"),

newThreadPoolExecutor.CallerRunsPolicy());

newThreadPoolExecutor(
2,3,30,TimeUnit.SECONDS,
newSynchronousQueue<Runnable>(),
newRecorderThreadFactory("CookieRecorderPool"),
newThreadPoolExecutor.CallerRunsPolicy());
当核心线程已经有2个正在运行.

此时继续来了一个任务（A），根据前面介绍的“如果运行的线程等于或多于corePoolSize，则Executor始终首选将请求加入队列，而不添加新的线程。”,所以A被添加到queue中。
又来了一个任务（B），且核心2个线程还没有忙完，OK，接下来首先尝试1中描述，但是由于使用的SynchronousQueue，所以一定无法加入进去。
此时便满足了上面提到的“如果无法将请求加入队列，则创建新的线程，除非创建此线程超出maximumPoolSize，在这种情况下，任务将被拒绝。”，所以必然会新建一个线程来运行这个任务。
暂时还可以，但是如果这三个任务都还没完成，连续来了两个任务，第一个添加入queue中，后一个呢？queue中无法插入，而线程数达到了maximumPoolSize，所以只好执行异常策略了。

所以在使用SynchronousQueue通常要求maximumPoolSize是无界的，这样就可以避免上述情况发生（如果希望限制就直接使用有界队列）。对于使用SynchronousQueue的作用jdk中写的很清楚：此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。
什么意思？如果你的任务A1，A2有内部关联，A1需要先运行，那么先提交A1，再提交A2，当使用SynchronousQueue我们可以保证，A1必定先被执行，在A1么有被执行前，A2不可能添加入queue中。
例子二：使用无界队列策略，即LinkedBlockingQueue
这个就拿newFixedThreadPool来说，根据前文提到的规则：
如果运行的线程少于corePoolSize，则Executor始终首选添加新的线程，而不进行排队。那么当任务继续增加，会发生什么呢？
如果运行的线程等于或多于corePoolSize，则Executor始终首选将请求加入队列，而不添加新的线程。OK，此时任务变加入队列之中了，那什么时候才会添加新线程呢？
如果无法将请求加入队列，则创建新的线程，除非创建此线程超出maximumPoolSize，在这种情况下，任务将被拒绝。这里就很有意思了，可能会出现无法加入队列吗？不像SynchronousQueue那样有其自身的特点，对于无界队列来说，总是可以加入的（资源耗尽，当然另当别论）。换句说，永远也不会触发产生新的线程！corePoolSize大小的线程数会一直运行，忙完当前的，就从队列中拿任务开始运行。所以要防止任务疯长，比如任务运行的实行比较长，而添加任务的速度远远超过处理任务的时间，而且还不断增加，不一会儿就爆了。
例子三：有界队列，使用ArrayBlockingQueue。
这个是最为复杂的使用，所以JDK不推荐使用也有些道理。与上面的相比，最大的特点便是可以防止资源耗尽的情况发生。
举例来说，请看如下构造方法：
1.newThreadPoolExecutor(

2.2,4,30,TimeUnit.SECONDS,

3.newArrayBlockingQueue<Runnable>(2),

4.newRecorderThreadFactory("CookieRecorderPool"),

5.newThreadPoolExecutor.CallerRunsPolicy());
newThreadPoolExecutor(
2,4,30,TimeUnit.SECONDS,
newArrayBlockingQueue<Runnable>(2),
newRecorderThreadFactory("CookieRecorderPool"),
newThreadPoolExecutor.CallerRunsPolicy());
假设，所有的任务都永远无法执行完。
对于首先来的A,B来说直接运行，接下来，如果来了C,D，他们会被放到queue中，如果接下来再来E,F，则增加线程运行E，F。但是如果再来任务，队列无法再接受了，线程数也到达最大的限制了，所以就会使用拒绝策略来处理。
keepAliveTime
jdk中的解释是：当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
有点拗口，其实这个不难理解，在使用了“池”的应用中，大多都有类似的参数需要配置。比如数据库连接池，DBCP中的maxIdle，minIdle参数。
什么意思？接着上面的解释，后来向老板派来的工人始终是“借来的”，俗话说“有借就有还”，但这里的问题就是什么时候还了，如果借来的工人刚完成一个任务就还回去，后来发现任务还有，那岂不是又要去借？这一来一往，老板肯定头也大死了。

合理的策略：既然借了，那就多借一会儿。直到“某一段”时间后，发现再也用不到这些工人时，便可以还回去了。这里的某一段时间便是keepAliveTime的含义，TimeUnit为keepAliveTime值的度量。

RejectedExecutionHandler
另一种情况便是，即使向老板借了工人，但是任务还是继续过来，还是忙不过来，这时整个队伍只好拒绝接受了。
RejectedExecutionHandler接口提供了对于拒绝任务的处理的自定方法的机会。在ThreadPoolExecutor中已经默认包含了4中策略，因为源码非常简单，这里直接贴出来。
CallerRunsPolicy：线程调用运行该任务的execute本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
1.publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){

2.if(!e.isShutdown()){

3.r.run();

4.}

5.}
publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){
if(!e.isShutdown()){
r.run();
}
}
这个策略显然不想放弃执行任务。但是由于池中已经没有任何资源了，那么就直接使用调用该execute的线程本身来执行。
AbortPolicy：处理程序遭到拒绝将抛出运行时RejectedExecutionException
1.publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){

2.thrownewRejectedExecutionException();

3.}
publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){
thrownewRejectedExecutionException();
}
这种策略直接抛出异常，丢弃任务。
DiscardPolicy：不能执行的任务将被删除
1.publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){

2.}
publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){
}
这种策略和AbortPolicy几乎一样，也是丢弃任务，只不过他不抛出异常。
DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）
1.publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){

2.if(!e.isShutdown()){

3.e.getQueue().poll();

4.e.execute(r);

5.}

}

publicvoidrejectedExecution(Runnabler,ThreadPoolExecutore){
if(!e.isShutdown()){
e.getQueue().poll();
e.execute(r);
}
}
该策略就稍微复杂一些，在pool没有关闭的前提下首先丢掉缓存在队列中的最早的任务，然后重新尝试运行该任务。这个策略需要适当小心。
设想:如果其他线程都还在运行，那么新来任务踢掉旧任务，缓存在queue中，再来一个任务又会踢掉queue中最老任务。
总结：
keepAliveTime和maximumPoolSize及BlockingQueue的类型均有关系。如果BlockingQueue是无界的，那么永远不会触发maximumPoolSize，自然keepAliveTime也就没有了意义。
反之，如果核心数较小，有界BlockingQueue数值又较小，同时keepAliveTime又设的很小，如果任务频繁，那么系统就会频繁的申请回收线程。
publicstaticExecutorServicenewFixedThreadPool(intnThreads){
returnnewThreadPoolExecutor(nThreads,nThreads,
0L,TimeUnit.MILLISECONDS,
newLinkedBlockingQueue<Runnable>());
}

Java并发编程：线程池的使用

Java并发编程：线程池的使用
　　在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：
　　如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
　　那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？
　　在Java中可以通过线程池来达到这样的效果。今天我们就来详细讲解一下Java的线程池，首先我们从最核心的ThreadPoolExecutor类中的方法讲起，然后再讲述它的实现原理，接着给出了它的使用示例，最后讨论了一下如何合理配置线程池的大小。
　　以下是本文的目录大纲：
　　一.Java中的ThreadPoolExecutor类
　　二.深入剖析线程池实现原理
　　三.使用示例
　　四.如何合理配置线程池的大小　
　　若有不正之处请多多谅解，并欢迎批评指正。
　　请尊重作者劳动成果，转载请标明原文链接：
　　http://www.cnblogs.com/dolphin0520/p/3932921.html

一.Java中的ThreadPoolExecutor类

　　java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。下面我们来看一下ThreadPoolExecutor类的具体实现源码。
　　在ThreadPoolExecutor类中提供了四个构造方法：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class ThreadPoolExecutor extends AbstractExecutorService { ..... 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,RejectedExecutionHandlerhandler); ... }

　　从上面的代码可以得知，ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，事实上，通过观察每个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工作。
　　下面解释下一下构造器中各个参数的含义：

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：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

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

threadFactory：线程工厂，主要用来创建线程；
handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

　　具体参数的配置与线程池的关系将在下一节讲述。
　　从上面给出的ThreadPoolExecutor类的代码可以知道，ThreadPoolExecutor继承了AbstractExecutorService，我们来看一下AbstractExecutorService的实现：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public abstract class AbstractExecutorService implements ExecutorService { protected <T> RunnableFuture<T>newTaskFor(Runnablerunnable,Tvalue){}; protected <T> RunnableFuture<T>newTaskFor(Callable<T>callable){}; public Future<?> submit(Runnabletask){}; public <T> Future<T>submit(Runnabletask,Tresult){}; public <T> Future<T>submit(Callable<T>task){}; private <T> TdoInvokeAny(Collection<? extends Callable<T>> tasks, boolean timed, long nanos) throws InterruptedException, ExecutionException,TimeoutException{ }; public <T> TinvokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException{ }; public <T> TinvokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnitunit) throws InterruptedException, ExecutionException,TimeoutException{ }; public <T> List<Future<T>>invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException { }; public <T> List<Future<T>>invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnitunit) throws InterruptedException { }; }

　　AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。
　　我们接着看ExecutorService接口的实现：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public interface ExecutorService extends Executor { void shutdown(); boolean isShutdown(); boolean isTerminated(); boolean awaitTermination( long timeout, TimeUnitunit) throws InterruptedException; <T>Future<T>submit(Callable<T>task); <T>Future<T>submit(Runnabletask,Tresult); Future<?>submit(Runnabletask); <T>List<Future<T>>invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException; <T>List<Future<T>>invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnitunit) throws InterruptedException; <T>TinvokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException; <T>TinvokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnitunit) throws InterruptedException, ExecutionException,TimeoutException; }

　　而ExecutorService又是继承了Executor接口，我们看一下Executor接口的实现：

?

1 2 3

public interface Executor { void execute(Runnable command); }

　　到这里，大家应该明白了ThreadPoolExecutor、AbstractExecutorService、ExecutorService和Executor几个之间的关系了。
　　Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；
　　然后ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；
　　抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；
　　然后ThreadPoolExecutor继承了类AbstractExecutorService。
　　在ThreadPoolExecutor类中有几个非常重要的方法：

?

1 2 3 4

execute() submit() shutdown() shutdownNow()

　　execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。
　　submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果（Future相关内容将在下一篇讲述）。
　　shutdown()和shutdownNow()是用来关闭线程池的。
　　还有很多其他的方法：
　　比如：getQueue()、getPoolSize()、getActiveCount()、getCompletedTaskCount()等获取与线程池相关属性的方法，有兴趣的朋友可以自行查阅API。

二.深入剖析线程池实现原理

　　在上一节我们从宏观上介绍了ThreadPoolExecutor，下面我们来深入解析一下线程池的具体实现原理，将从下面几个方面讲解：
1.线程池状态
　　2.任务的执行
　　3.线程池中的线程初始化
　　4.任务缓存队列及排队策略
　　5.任务拒绝策略
　　6.线程池的关闭
　　7.线程池容量的动态调整

1.线程池状态
　　在ThreadPoolExecutor中定义了一个volatile变量，另外定义了几个staticfinal变量表示线程池的各个状态：

?

1 2 3 4 5

volatile int runState; static final int RUNNING = 0 ; static final int SHUTDOWN = 1 ; static final int STOP = 2 ; static final int TERMINATED = 3 ;

　　runState表示当前线程池的状态，它是一个volatile变量用来保证线程之间的可见性；
　　下面的几个staticfinal变量表示runState可能的几个取值。
　　当创建线程池后，初始时，线程池处于RUNNING状态；
　　如果调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；
　　如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；
　　当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。
2.任务的执行
　　在了解将任务提交给线程池到任务执行完毕整个过程之前，我们先来看一下ThreadPoolExecutor类中其他的一些比较重要成员变量：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

private final BlockingQueue<Runnable> workQueue; //任务缓存队列，用来存放等待执行的任务 private final ReentrantLock mainLock= new ReentrantLock(); //线程池的主要状态锁，对线程池状态（比如线程池大小 //、runState等）的改变都要使用这个锁 private final HashSet<Worker> workers= new HashSet<Worker>(); //用来存放工作集 private volatile long keepAliveTime; //线程存货时间 private volatile boolean allowCoreThreadTimeOut; //是否允许为核心线程设置存活时间 private volatile int corePoolSize; //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列） private volatile int maximumPoolSize; //线程池最大能容忍的线程数 private volatile int poolSize; //线程池中当前的线程数 private volatile RejectedExecutionHandler handler; //任务拒绝策略 private volatile ThreadFactory threadFactory; //线程工厂，用来创建线程 private int largestPoolSize; //用来记录线程池中曾经出现过的最大线程数 private long completedTaskCount; //用来记录已经执行完毕的任务个数

　　每个变量的作用都已经标明出来了，这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。
　　corePoolSize在很多地方被翻译成核心池大小，其实我的理解这个就是线程池的大小。举个简单的例子：
　　假如有一个工厂，工厂里面有10个工人，每个工人同时只能做一件任务。
　　因此只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人做；
　　当10个工人都有任务在做时，如果还来了任务，就把任务进行排队等待；
　　如果说新任务数目增长的速度远远大于工人做任务的速度，那么此时工厂主管可能会想补救措施，比如重新招4个临时工人进来；
　　然后就将任务也分配给这4个临时工人做；
　　如果说着14个工人做任务的速度还是不够，此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。
　　当这14个工人当中有人空闲时，而新任务增长的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。

　　这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。
　　也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量突然过大时的一种补救措施。
　　不过为了方便理解，在本文后面还是将corePoolSize翻译成核心池大小。
　　largestPoolSize只是一个用来起记录作用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。

　　下面我们进入正题，看一下任务从提交到最终执行完毕经历了哪些过程。
　　在ThreadPoolExecutor类中，最核心的任务提交方法是execute()方法，虽然通过submit也可以提交任务，但是实际上submit方法里面最终调用的还是execute()方法，所以我们只需要研究execute()方法的实现原理即可：

?

1 2 3 4 5 6 7 8 9 10 11 12

public void execute(Runnable command){ if (command == null ) throw new NullPointerException(); if (poolSize >=corePoolSize||!addIfUnderCorePoolSize(command)){ if (runState ==RUNNING&&workQueue.offer(command)){ if (runState !=RUNNING||poolSize== 0 ) ensureQueuedTaskHandled(command); } else if (!addIfUnderMaximumPoolSize(command)) reject(command); // isshutdownorsaturated } }

　　上面的代码可能看起来不是那么容易理解，下面我们一句一句解释：
　　首先，判断提交的任务command是否为null，若是null，则抛出空指针异常；
　　接着是这句，这句要好好理解一下：

?

1	if (poolSize>=corePoolSize||!addIfUnderCorePoolSize(command))

　　由于是或条件运算符，所以先计算前半部分的值，如果线程池中当前线程数不小于核心池大小，那么就会直接进入下面的if语句块了。
　　如果线程池中当前线程数小于核心池大小，则接着执行后半部分，也就是执行

?

1	addIfUnderCorePoolSize(command)

　　如果执行完addIfUnderCorePoolSize这个方法返回false，则继续执行下面的if语句块，否则整个方法就直接执行完毕了。
　　如果执行完addIfUnderCorePoolSize这个方法返回false，然后接着判断：

?

1	if (runState==RUNNING&&workQueue.offer(command))

　　如果当前线程池处于RUNNING状态，则将任务放入任务缓存队列；如果当前线程池不处于RUNNING状态或者任务放入缓存队列失败，则执行：

?

1	addIfUnderMaximumPoolSize(command)

　　如果执行addIfUnderMaximumPoolSize方法失败，则执行reject()方法进行任务拒绝处理。
　　回到前面：

?

1	if (runState==RUNNING&&workQueue.offer(command))

　　这句的执行，如果说当前线程池处于RUNNING状态且将任务放入任务缓存队列成功，则继续进行判断：

?

1	if (runState!=RUNNING||poolSize== 0 )

　　这句判断是为了防止在将此任务添加进任务缓存队列的同时其他线程突然调用shutdown或者shutdownNow方法关闭了线程池的一种应急措施。如果是这样就执行：

?

1	ensureQueuedTaskHandled(command)

　　进行应急处理，从名字可以看出是保证添加到任务缓存队列中的任务得到处理。
　　我们接着看2个关键方法的实现：addIfUnderCorePoolSize和addIfUnderMaximumPoolSize：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

private boolean addIfUnderCorePoolSize(Runnable firstTask){ Threadt= null ; final ReentrantLock mainLock= this .mainLock; mainLock.lock(); try { if (poolSize <corePoolSize&&runState==RUNNING) t=addThread(firstTask); //创建线程去执行firstTask任务 } finally { mainLock.unlock(); } if (t == null ) return false ; t.start(); return true ; }

　　这个是addIfUnderCorePoolSize方法的具体实现，从名字可以看出它的意图就是当低于核心吃大小时执行的方法。下面看其具体实现，首先获取到锁，因为这地方涉及到线程池状态的变化，先通过if语句判断当前线程池中的线程数目是否小于核心池大小，有朋友也许会有疑问：前面在execute()方法中不是已经判断过了吗，只有线程池当前线程数目小于核心池大小才会执行addIfUnderCorePoolSize方法的，为何这地方还要继续判断？原因很简单，前面的判断过程中并没有加锁，因此可能在execute方法判断的时候poolSize小于corePoolSize，而判断完之后，在其他线程中又向线程池提交了任务，就可能导致poolSize不小于corePoolSize了，所以需要在这个地方继续判断。然后接着判断线程池的状态是否为RUNNING，原因也很简单，因为有可能在其他线程中调用了shutdown或者shutdownNow方法。然后就是执行

?

1	t=addThread(firstTask);

　　这个方法也非常关键，传进去的参数为提交的任务，返回值为Thread类型。然后接着在下面判断t是否为空，为空则表明创建线程失败（即poolSize>=corePoolSize或者runState不等于RUNNING），否则调用t.start()方法启动线程。
　　我们来看一下addThread方法的实现：

?

1 2 3 4 5 6 7 8 9 10 11 12

private ThreadaddThread(RunnablefirstTask){ Workerw= new Worker(firstTask); Threadt=threadFactory.newThread(w); //创建一个线程，执行任务 if (t != null ){ w.thread=t; //将创建的线程的引用赋值为w的成员变量 workers.add(w); int nt =++poolSize; //当前线程数加1 if (nt >largestPoolSize) largestPoolSize=nt; } return t; }

　　在addThread方法中，首先用提交的任务创建了一个Worker对象，然后调用线程工厂threadFactory创建了一个新的线程t，然后将线程t的引用赋值给了Worker对象的成员变量thread，接着通过workers.add(w)将Worker对象添加到工作集当中。
　　下面我们看一下Worker类的实现：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

private final class Worker implements Runnable { private final ReentrantLock runLock= new ReentrantLock(); private Runnable firstTask; volatile long completedTasks; Threadthread; Worker(RunnablefirstTask){ this .firstTask =firstTask; } boolean isActive() { return runLock.isLocked(); } void interruptIfIdle() { final ReentrantLock runLock= this .runLock; if (runLock.tryLock()) { try { if (thread !=Thread.currentThread()) thread.interrupt(); } finally { runLock.unlock(); } } } void interruptNow() { thread.interrupt(); } private void runTask(Runnable task){ final ReentrantLock runLock= this .runLock; runLock.lock(); try { if (runState <STOP&& Thread.interrupted()&& runState>=STOP) boolean ran = false ; beforeExecute(thread,task); //beforeExecute方法是ThreadPoolExecutor类的一个方法，没有具体实现，用户可以根据 //自己需要重载这个方法和后面的afterExecute方法来进行一些统计信息，比如某个任务的执行时间等 try { task.run(); ran= true ; afterExecute(task, null ); ++completedTasks; } catch (RuntimeException ex){ if (!ran) afterExecute(task,ex); throw ex; } } finally { runLock.unlock(); } } public void run() { try { Runnabletask=firstTask; firstTask= null ; while (task != null ||(task=getTask())!= null ) { runTask(task); task= null ; } } finally { workerDone( this ); //当任务队列中没有任务时，进行清理工作 } } }

　　它实际上实现了Runnable接口，因此上面的Threadt=threadFactory.newThread(w);效果跟下面这句的效果基本一样：

?

1	Threadt= new Thread(w);

　　相当于传进去了一个Runnable任务，在线程t中执行这个Runnable。
　　既然Worker实现了Runnable接口，那么自然最核心的方法便是run()方法了：

?

1 2 3 4 5 6 7 8 9 10 11 12

public void run() { try { Runnabletask=firstTask; firstTask= null ; while (task != null ||(task=getTask())!= null ) { runTask(task); task= null ; } } finally { workerDone( this ); } }

　　从run方法的实现可以看出，它首先执行的是通过构造器传进来的任务firstTask，在调用runTask()执行完firstTask之后，在while循环里面不断通过getTask()去取新的任务来执行，那么去哪里取呢？自然是从任务缓存队列里面去取，getTask是ThreadPoolExecutor类中的方法，并不是Worker类中的方法，下面是getTask方法的实现：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

RunnablegetTask(){ for (;;) { try { int state =runState; if (state >SHUTDOWN) return null ; Runnabler; if (state ==SHUTDOWN) //Helpdrainqueue r=workQueue.poll(); else if (poolSize >corePoolSize||allowCoreThreadTimeOut) //如果线程数大于核心池大小或者允许为核心池线程设置空闲时间， //则通过poll取任务，若等待一定的时间取不到任务，则返回null r=workQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS); else r=workQueue.take(); if (r != null ) return r; if (workerCanExit()) { //如果没取到任务，即r为null，则判断当前的worker是否可以退出 if (runState >=SHUTDOWN) //Wakeupothers interruptIdleWorkers(); //中断处于空闲状态的worker return null ; } //Elseretry } catch (InterruptedException ie){ //Oninterruption,re-checkrunState } } }

　　在getTask中，先判断当前线程池状态，如果runState大于SHUTDOWN（即为STOP或者TERMINATED），则直接返回null。
　　如果runState为SHUTDOWN或者RUNNING，则从任务缓存队列取任务。
　　如果当前线程池的线程数大于核心池大小corePoolSize或者允许为核心池中的线程设置空闲存活时间，则调用poll(time,timeUnit)来取任务，这个方法会等待一定的时间，如果取不到任务就返回null。
　　然后判断取到的任务r是否为null，为null则通过调用workerCanExit()方法来判断当前worker是否可以退出，我们看一下workerCanExit()的实现：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

private boolean workerCanExit() { final ReentrantLock mainLock= this .mainLock; mainLock.lock(); boolean canExit; //如果runState大于等于STOP，或者任务缓存队列为空了 //或者允许为核心池线程设置空闲存活时间并且线程池中的线程数目大于1 try { canExit=runState>=STOP|| workQueue.isEmpty()|| (allowCoreThreadTimeOut&& poolSize>Math.max( 1 , corePoolSize)); } finally { mainLock.unlock(); } return canExit; }

　　也就是说如果线程池处于STOP状态、或者任务队列已为空或者允许为核心池线程设置空闲存活时间并且线程数大于1时，允许worker退出。如果允许worker退出，则调用interruptIdleWorkers()中断处于空闲状态的worker，我们看一下interruptIdleWorkers()的实现：

?

1 2 3 4 5 6 7 8 9 10

void interruptIdleWorkers(){ final ReentrantLock mainLock= this .mainLock; mainLock.lock(); try { for (Worker w:workers) //实际上调用的是worker的interruptIfIdle()方法 w.interruptIfIdle(); } finally { mainLock.unlock(); } }

　　从实现可以看出，它实际上调用的是worker的interruptIfIdle()方法，在worker的interruptIfIdle()方法中：

?

1 2 3 4 5 6 7 8 9 10 11 12

void interruptIfIdle(){ final ReentrantLock runLock= this .runLock; if (runLock.tryLock()) { //注意这里，是调用tryLock()来获取锁的，因为如果当前worker正在执行任务，锁已经被获取了，是无法获取到锁的 //如果成功获取了锁，说明当前worker处于空闲状态 try { if (thread !=Thread.currentThread()) thread.interrupt(); } finally { runLock.unlock(); } } }

　　这里有一个非常巧妙的设计方式，假如我们来设计线程池，可能会有一个任务分派线程，当发现有线程空闲时，就从任务缓存队列中取一个任务交给空闲线程执行。但是在这里，并没有采用这样的方式，因为这样会要额外地对任务分派线程进行管理，无形地会增加难度和复杂度，这里直接让执行完任务的线程去任务缓存队列里面取任务来执行。
　　我们再看addIfUnderMaximumPoolSize方法的实现，这个方法的实现思想和addIfUnderCorePoolSize方法的实现思想非常相似，唯一的区别在于addIfUnderMaximumPoolSize方法是在线程池中的线程数达到了核心池大小并且往任务队列中添加任务失败的情况下执行的：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

private boolean addIfUnderMaximumPoolSize(Runnable firstTask){ Threadt= null ; final ReentrantLock mainLock= this .mainLock; mainLock.lock(); try { if (poolSize <maximumPoolSize&&runState==RUNNING) t=addThread(firstTask); } finally { mainLock.unlock(); } if (t == null ) return false ; t.start(); return true ; }

　　看到没有，其实它和addIfUnderCorePoolSize方法的实现基本一模一样，只是if语句判断条件中的poolSize<maximumPoolSize不同而已。
　　到这里，大部分朋友应该对任务提交给线程池之后到被执行的整个过程有了一个基本的了解，下面总结一下：
　　1）首先，要清楚corePoolSize和maximumPoolSize的含义；
　　2）其次，要知道Worker是用来起到什么作用的；
　　3）要知道任务提交给线程池之后的处理策略，这里总结一下主要有4点：

如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；
如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；
如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；
如果线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

3.线程池中的线程初始化
　　默认情况下，创建线程池之后，线程池中是没有线程的，需要提交任务之后才会创建线程。
　　在实际中如果需要线程池创建之后立即创建线程，可以通过以下两个方法办到：

prestartCoreThread()：初始化一个核心线程；
prestartAllCoreThreads()：初始化所有核心线程

　　下面是这2个方法的实现：

?

1 2 3 4 5 6 7 8 9 10

public boolean prestartCoreThread() { return addIfUnderCorePoolSize( null ); //注意传进去的参数是null } public int prestartAllCoreThreads() { int n = 0 ; while (addIfUnderCorePoolSize( null )) //注意传进去的参数是null ++n; return n; }

　　注意上面传进去的参数是null，根据第2小节的分析可知如果传进去的参数为null，则最后执行线程会阻塞在getTask方法中的

?

1	r=workQueue.take();

　　即等待任务队列中有任务。
4.任务缓存队列及排队策略
　　在前面我们多次提到了任务缓存队列，即workQueue，它用来存放等待执行的任务。
　　workQueue的类型为BlockingQueue<Runnable>，通常可以取下面三种类型：
　　1）ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；
　　2）LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
　　3）synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
5.任务拒绝策略
　　当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：

?

1 2 3 4

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程） ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

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

shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

7.线程池容量的动态调整
　　ThreadPoolExecutor提供了动态调整线程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，

setCorePoolSize：设置核心池大小
setMaximumPoolSize：设置线程池最大能创建的线程数目大小

　　当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还可能立即创建新的线程来执行任务。

三.使用示例

　　前面我们讨论了关于线程池的实现原理，这一节我们来看一下它的具体使用：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

public class Test { public static void main(String[] args){ ThreadPoolExecutorexecutor= new ThreadPoolExecutor( 5 , 10 , 200 , TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>( 5 )); for ( int i= 0 ;i< 15 ;i++){ MyTaskmyTask= new MyTask(i); executor.execute(myTask); System.out.println( "线程池中线程数目：" +executor.getPoolSize()+ "，队列中等待执行的任务数目：" + executor.getQueue().size()+ "，已执行玩别的任务数目：" +executor.getCompletedTaskCount()); } executor.shutdown(); } } class MyTask implements Runnable { private int taskNum; public MyTask( int num) { this .taskNum =num; } @Override public void run() { System.out.println( "正在执行task " +taskNum); try { Thread.currentThread().sleep( 4000 ); } catch (InterruptedException e){ e.printStackTrace(); } System.out.println( "task " +taskNum+ "执行完毕" ); } }

　　执行结果：

正在执行task0
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task1
线程池中线程数目：3，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task2
线程池中线程数目：4，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task3
线程池中线程数目：5，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task4
线程池中线程数目：5，队列中等待执行的任务数目：1，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：2，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：3，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：4，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
线程池中线程数目：6，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task10
线程池中线程数目：7，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task11
线程池中线程数目：8，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task12
线程池中线程数目：9，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task13
线程池中线程数目：10，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task14
task3执行完毕
task0执行完毕
task2执行完毕
task1执行完毕
正在执行task8
正在执行task7
正在执行task6
正在执行task5
task4执行完毕
task10执行完毕
task11执行完毕
task13执行完毕
task12执行完毕
正在执行task9
task14执行完毕
task8执行完毕
task5执行完毕
task7执行完毕
task6执行完毕
task9执行完毕

ViewCode
　　从执行结果可以看出，当线程池中线程的数目大于5时，便将任务放入任务缓存队列里面，当任务缓存队列满了之后，便创建新的线程。如果上面程序中，将for循环中改成执行20个任务，就会抛出任务拒绝异常了。
　　不过在javadoc中，并不提倡我们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池：

?

1 2 3

Executors.newCachedThreadPool(); //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE Executors.newSingleThreadExecutor(); //创建容量为1的缓冲池 Executors.newFixedThreadPool( int ); //创建固定容量大小的缓冲池

　　下面是这三个静态方法的具体实现;

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public static ExecutorService newFixedThreadPool( int nThreads){ return new ThreadPoolExecutor(nThreads, nThreads, 0L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); } public static ExecutorService newSingleThreadExecutor(){ return new FinalizableDelegatedExecutorService ( new ThreadPoolExecutor( 1 , 1 , 0L,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); } public static ExecutorService newCachedThreadPool(){ return new ThreadPoolExecutor( 0 , Integer.MAX_VALUE, 60L,TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }

　　从它们的具体实现来看，它们实际上也是调用了ThreadPoolExecutor，只不过参数都已配置好了。
　　newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue；
　　newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，也使用的LinkedBlockingQueue；
　　newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。
　　实际中，如果Executors提供的三个静态方法能满足要求，就尽量使用它提供的三个方法，因为自己去手动配置ThreadPoolExecutor的参数有点麻烦，要根据实际任务的类型和数量来进行配置。
　　另外，如果ThreadPoolExecutor达不到要求，可以自己继承ThreadPoolExecutor类进行重写。

四.如何合理配置线程池的大小

　　本节来讨论一个比较重要的话题：如何合理配置线程池大小，仅供参考。
　　一般需要根据任务的类型来配置线程池大小：
　　如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为NCPU+1
　　如果是IO密集型任务，参考值可以设置为2*NCPU
　　当然，这只是一个参考值，具体的设置还需要根据实际情况进行调整，比如可以先将线程池大小设置为参考值，再观察任务运行情况和系统负载、资源利用率来进行适当调整。