---

I. 可设置的主要参数

全部参数的构造函数：

public ThreadPoolExecutor(int corePoolSize,  // 核心线程数
                          int maximumPoolSize, // 允许的最大线程数
                          long keepAliveTime, // 线程保持存活的时间值
                          TimeUnit unit, // 时间单位
                          BlockingQueue<Runnable> workQueue, // 工作队列
                          ThreadFactory threadFactory, // 线程工厂：如何创建一个线程
                          RejectedExecutionHandler handler) { // 任务拒绝处理策略
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

I-1. corePoolSize

核心线程数。

当线程数小于核心线程数时，即使现有的线程空闲，线程池也会优先创建新线程来处理任务，而不是直接交给现有的线程处理。已创建的核心线程会一直存活，即使没有任务需要处理。

核心线程在allowCoreThreadTimeout被设置为true时会超时退出，默认情况下不会退出。

I-2. maximumPoolSize

允许的最大线程数。

该参数排队策略为『无界队列』的情况下是无效的。具体见工作队列中的排列策略描述。

I-3. keepAliveTime

线程保持存活的时间值；TimeUnit 给定时间单位。

如果池中当前有多于 corePoolSize 的线程，则这些多出的线程在空闲时间小于keepAliveTime，又来了新的任务时，会复用该线程；反之，当线程空闲时间超过keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。

如果allowCoreThreadTimeout设置为true，则所有线程超出keepAliveTime， 均会退出直到线程数量为0。

• allowCoreThreadTimeout

是否允许核心线程空闲退出，默认值为false。
通过方法 allowsCoreThreadTimeOut(boolean value) 设置。

I-4. workQueue

工作队列。类型为 BlockingQueue<Runnable>。

所有 BlockingQueue 都可用于传输和保持提交的任务。

• 如果运行的线程少于 corePoolSize，则创建新的线程，不会将任务入队。
• 如果运行的线程多于 corePoolSize，可能会加入队列，也可能会直接创建新的线程来执行任务；受排队策略的影响。

I-4-a. 工作队列排队策略：直接提交

工作队列 SynchronousQueue(同步队列)，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交，通常要求无界的 maximumPoolSizes 以避免拒绝新提交的任务，即 maximumPoolSizes=Integer.MAX_VALUE (它虽然也是一个具体的数字，但过于庞大，看成无界)。

简单来说，直接提交，工作队列不保持任务，无空闲线程时，会新开线程，直到线程数达到 maximumPoolSizes。

SynchronousQueue 的特点是，每个插入操作必须等待另一个线程的对应移除操作。比如，要添加一个元素，接下来如果继续想尝试添加则会阻塞，直到另一个线程取走一个元素，反之亦然。
SynchronousQueue 不会保留任务进队列，会直接提交到工作线程。如果maximumPoolSizes是无界，那任务不停的开启，就会不停的创建工作线程。如果是有界的，那工作线程数达到maximumPoolSizes时，再有一个任务入队后，就会阻塞，直到一个线程空闲，出队一个任务给到线程去执行。

I-4-b. 工作队列排队策略：无界队列

即不限定队列的容量。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求。

简单来说，无界队列使用未指定容量的 BlockingQueue (它是一个接口，可自行查看下它的家谱)，线程数不超过corePoolSize，多余任务在队列中等待。maximumPoolSize无效。

I-4-c. 工作队列排队策略： 有界队列

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

简单来说，限定了队列的边界，并使用有限的maximumPoolSizes。工作中的线程未达到maximumPoolSizes，又有新的任务进来时，会创建新的线程；线程达到maximumPoolSizes时，新任务入队列；在队列饱和且线程数达到maximumPoolSizes时，新的任务将被拒绝，受RejectedExecutionHandler影响。

I-5. ThreadFactory

线程工厂，用于创建新的线程。该接口只有一个抽象方法：

Thread newThread(Runnable r);

I-6. RejectedExecutionHandler

public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

任务拒绝处理策略。
当 线程池 关闭时，会触发该策略。
或者 使用有限边界和有限的 maximumPoolSizes，且已经饱和时，会触发该策略。

在源码中定义了如下几种策略：

I-6-a. AbortPolicy (默认策略)

public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

该策略 直接抛出了异常。

I-6-b. CallerRunsPolicy

public static class CallerRunsPolicy implements RejectedExecutionHandler {
  public CallerRunsPolicy() { }
  public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
      if (!e.isShutdown()) {
          r.run();
      }
  }
}

直接在当前线程执行任务。所谓当前线程，即提交任务时的线程，即调用 ThreadPoolExecutor#execute()的线程。

I-6-c. DiscardPolicy

public static class DiscardPolicy implements RejectedExecutionHandler {
  public DiscardPolicy() { }
  public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
  }
}

丢弃新任务。不做任何处理，跳过任务 r

I-6-d. DiscardOldestPolicy

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
   public DiscardOldestPolicy() { }
   public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
       if (!e.isShutdown()) {
           e.getQueue().poll();
           e.execute(r);
       }
   }
}

在线程池未关闭时，移除处于队头的任务，再执行任务r。
也就是 把之前队头的任务跳过了，把r又加入了队列

---

II. Executors生成ThreadPoolExecutor

II-1. 生成一个固定线程数的ThreadPoolExecutor

public static ExecutorService newFixedThreadPool(int nThreads) {

​    return new ThreadPoolExecutor(nThreads, nThreads,
​                                  0L, TimeUnit.MILLISECONDS,
​                                  new LinkedBlockingQueue<Runnable>());

}

无界队列实现，线程数不会超过第一个参数 nThreads； 第二个参数 nThreads失效。线程保活时间0。
LinkedBlockingQueue 是线程安全的，实现了先进先出等特性，是作为生产者消费者的首选，LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的话，默认最大是Integer.MAX_VALUE

II-2. 生成一个只含一个线程的ThreadPoolExecutor

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

无界队列实现，线程数不会超过第一个参数 1； 第二个参数 1失效。线程保活时间0。

II-3. 生成一个线程缓存的ThreadPoolExecutor

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

核心线程数0，最大线程数是无界的。
直接提交，按需创建新线程。线程保活时间60秒。

---

III. 线程池的关闭

两个方法 shutdownNow() 和 shutdown();

III-1. shutdownNow()

内部会立即试图调用 线程 Thread#interrupt()，来打断线程。
若线程中有 Thread.sleep() 或 Object#wait() 阻塞了线程，此时调用后就会造成异常。
所以线程内部运行的代码最好加上try-catch代码块。

III-2. shutdown()

等待线程内部任务执行完毕，再关闭线程池。
即使线程中有 Thread.sleep() 或 Object#wait() 阻塞了线程，调用后也不会造成异常。
但最好对线程内部运行的代码加上try-catch代码块，因为可能是其它方面发生了异常。

通常在程序中，仅在退出程序前，调用关闭线程池的操作。

---

IV. 常用函数

IV-1. isShutdown() isTerminated()

isShutdown() 在 线程池已关闭后，即调用shutdown()/shutdownNow()，会返回true。
isTerminated() 在 线程池已关闭后，即调用shutdown()/shutdownNow()，会返回true 或者 false；取决于池内的所有任务是否都已关闭。

IV-2. getActiveCount()

返回主动执行任务的近似线程数。
因为在计算期间任务和线程的状态可能动态改变，所以返回值只是一个近似值。

IV-3. getTaskCount()

返回曾计划执行的近似任务总数。

IV-4. getCompletedTaskCount()

返回已完成执行的近似任务总数。

IV-5. awaitTermination(long timeout, TimeUnit unit)

等待终止。给一个超时时间。
超时时间前终止，返回true；超时期满，未终止，返回 false。
需要与shutdown()/shutdownNow() 配合使用。

---

V. 测试

  private ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10,
            30L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(10), 
            new ThreadPoolExecutor.DiscardOldestPolicy());

测试时，使用不同的 队列，不同的 maximumPoolSize，不同的 RejectedExecutionHandler来测试。

---