(1)、定义：

public ThreadPoolExecutor(int corePoolSize,

                               int maximumPoolSize,

                               long keepAliveTime,

                               TimeUnit unit,

                               BlockingQueue<Runnable> workQueue,

                               RejectedExecutionHandler handler)




(2)、参数说明：
corePoolSize 指的是保留的线程池大小。
maximumPoolSize 指的是线程池的最大大小。
keepAliveTime 指的是空闲线程结束的超时时间。
unit 是一个枚举，表示 keepAliveTime 的单位。
workQueue 表示存放任务的队列。
RejectedExecutionHandler  添加任务失败后的执行策略,你可以调用线程池的 setRejectedExecutionHandler() 方法，用自定义的 RejectedExecutionHandler 对象替换现有的策略。

(3)、具体流程如下：
1、线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
2、当调用 execute() 方法添加一个任务时，线程池会做如下判断：
　　 a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
　　 b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。
　　 c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；
　　 d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。
3、当一个线程完成任务时，它会从队列中取下一个任务来执行。
4、另外，当池子的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁。

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

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

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

(5)、添加任务失败后的4种执行策略
ThreadPoolExecutor.AbortPolicy：表示拒绝任务并抛出异常
ThreadPoolExecutor.DiscardPolicy：表示拒绝任务但不做任何动作
ThreadPoolExecutor.CallerRunsPolicy：表示拒绝任务，并在调用者的线程中直接执行该任务
ThreadPoolExecutor.DiscardOldestPolicy：表示先丢弃任务队列中的第一个任务，然后把这个任务加进队列。

eg:使用有界队列策略。

假设队列大小为 10，corePoolSize 为 3，maximumPoolSize 为 6，那么当加入 20 个任务时，执行的顺序就是这样的：首先执行任务 1、2、3，然后任务 4-13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务17-20则会添加失败。最终顺序是：1、2、3、14、15、16、4、5、6、7、8、9、10、11、12。

public class ThreadPoolExe {
  
  class Task implements Runnable {
    private String name;
    public Task(String name) {
      this.name = name;
    }
    public void run() {
      System.out.println("the "+ name + " task");
      try {
        //模拟线程需要执行的时间
        Thread.sleep(20000);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
  
  public void execute(){
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3,6,3,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10),new ThreadPoolExecutor.DiscardPolicy());
    for(int i = 1; i<=20;i++) {
      Task task = new Task(""+i);
      threadPool.execute(task);
    }
  }
  
  public static void main(String[] args) {
    ThreadPoolExe t = new ThreadPoolExe();
    t.execute();
  }


输出结果：

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