Java Executor并发框架（四）创建线程池的核心参数的解释

一、ThreadPoolExecutor的相关属性

private final BlockingQueue<Runnable> workQueue;              // 任务阻塞队列

private final ReentrantLock mainLock = new ReentrantLock();   // 互斥锁

private final HashSet<Worker> workers = new HashSet<Worker>();// 线程集合.一个Worker对应一个线程

private final Condition termination = mainLock.newCondition();// 终止条件

private int largestPoolSize;           // 线程池中线程数量曾经达到过的最大值

private long completedTaskCount;       // 已完成任务数量

private volatile ThreadFactory threadFactory;     // ThreadFactory对象，用于创建线程。

private volatile RejectedExecutionHandler handler;// 拒绝策略的处理句柄

private volatile long keepAliveTime;   // 线程池维护线程所允许的空闲时间

private volatile boolean allowCoreThreadTimeOut;//是否允许核心线程也会timeout,默认是false

private volatile int corePoolSize;     // 线程池维护线程的最小数量，哪怕是空闲的

private volatile int maximumPoolSize;  // 线程池维护的最大线程数量

其中有几个重要的规则需要说明一下：

1、corePoolSize与maximumPoolSize ：由于ThreadPoolExecutor 将根据 corePoolSize和 maximumPoolSize设置的边界自动调整池大小，当执行 execute(java.lang.Runnable) 方法提交新任务时：

(1). 如果运行的线程少于 corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的；

(2). 如果设置的corePoolSize 和 maximumPoolSize相同，则创建的线程池是大小固定的，如果运行的线程与corePoolSize相同，当有新请求过来时，若workQueue任务阻塞队列未满，则将请求放入workQueue中，等待有空闲的线程从workQueue中取出任务并处理。

(3). 如果运行的线程多于 corePoolSize 而少于 maximumPoolSize，则仅当workQueue任务阻塞队列满时才创建新线程去处理请求；

(4). 如果运行的线程多于corePoolSize 并且等于maximumPoolSize，若workQueue任务阻塞队列已满，则通过handler所指定的策略来处理新请求；

(5). 如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务。

也就是说，处理任务的优先级为： 

• 1. 核心线程corePoolSize > 阻塞队列workQueue > 最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

• 2. 当池中的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求处理，就自行销毁。

corePoolSize：在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者 prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建 corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到阻塞队列当中；

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

2、 workQueue 线程池所使用的任务阻塞队列，该阻塞队列的长度决定了能够缓冲任务的最大数量，阻塞队列有以下三种选择：

ArrayBlockingQueue; //有界队列
LinkedBlockingQueue; //无界队列
SynchronousQueue; //特殊的一个队列，只有存在等待取出的线程时才能加入队列，可以说容量为0，是无界队列

ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。

线程池的排队策略与BlockingQueue有关。

缓冲队列有三种通用策略：

(1). 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;

(2). 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize（因此，maximumPoolSize 的值也就无效了）。当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;

(3). 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。

3、 keepAliveTime表示线程没有任务执行时最多保持多久时间会终止。

默认情况下，只有当线程池中的线程数大于corePoolSize 时，keepAliveTime才会起作用。

直到线程池中的线程数不大于corePoolSize。即当线程池中的线程数大于corePoolSize 时。

如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。

但是如果调用了 allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize 时，

keepAliveTime参数也会起作用，直到线程池中的线程数为0；

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

5.添加任务处理的流程

当一个任务通过execute(Runnable)方法欲添加到线程池时：

如果当前线程池中的数量小于corePoolSize，并线程池处于Running状态，创建并添加的任务。

如果当前线程池中的数量等于corePoolSize，并线程池处于Running状态，缓冲队列 workQueue未满，那么任务被放入缓冲队列、等待任务调度执行。
如果当前线程池中的数量大于corePoolSize，缓冲队列workQueue已满，并且线程池中的数量小于maximumPoolSize，新提交任务会创建新线程执行任务。

如果当前线程池中的数量大于corePoolSize，缓冲队列workQueue已满，并且线程池中的数量等于maximumPoolSize，新提交任务由Handler处理。

当线程池中的线程大于corePoolSize时，多余线程空闲时间超过keepAliveTime时，会关闭这部分线程。

6、 我们先看两张图

任务执行流程图 

任务队列图 

• 几个关键点
• corePoolSize: 核心线程池大小，线程池刚启动时来一个任务就会创建一个线程去执行这个任务，直到达到corePoolSize个线程，这时再来的任务就会加到任务队列中去，直到任务队列满了，这时会尝试创建新的线程，但是总线程数量必须少于maximumPoolSize，如果线程也不能创建了，这时就会拒绝执行任务了。
• maximumPoolSize: 最大线程数，线程池总线程数量不得多于maximumPoolSize
• keepAliveTime 线程存货时间，主要是在最大线程数到核心线程数之间的线程存活时间，比如corePoolSize = 10，maximumPoolSize =100。当线程池达到100时，这时每个线程不执行且过了keepAliveTime 的时间后就会消失，但是当线程池数量到达corePoolSize 线程不在消失。也就是说keepAliveTime 不起作用了。
• Queue任务队列 有三种类型（无限队列、直接队列、有限队列） 
  直接队列来一个任务会直接尝试创建新线程执行。 
  无限队列会当线程池数量达到corePoolSize 时新来的任务都会加入队列中，这时maximumPoolSize 就不起作用了。 
  有限队列在线程达到corePoolSize 且任务队列已满时来一个任务会尝试继续创建线程，知道达到maximumPoolSize
• 
  
• Executors是创建线程池的工厂类。提供了以下几个主要方法

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

  可以看出创建了一个核心线程数为0，最大线程数为一个Integer能表示的最大值，存活时间为60秒。队列为SynchronousQueue直接队列。这种情况下每来一个任务就创建一个线程执行。直到创建的线程数大于Integer.MAX_VALUE当然一般情况下不会出现。每一个线程的存货时间是60秒超过60秒后自动销毁。
• 
  

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

  可以看出创建了一个核心线程数为传入的nThreads，最大线程数也为nThreads，存活时间为0秒。队列为LinkedBlockingQueue即不保存队列任务。这种情况下每来一个任务首先看线程池数量有没有到nThreads，如果没有达到则创建一个新的线程并执行，否则加入队列中，等待执行。此处LinkedBlockingQueue没有指定大小即最多可以接收Integer.MAX_VALUE个缓冲任务。相当于创建了nThreads个线程来执行队列中的任务。
• 
  

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

  和上面的newFixedThreadPool类似，只不过这里只有一个线程，即使用一个线程执行任务队列中的任务。