public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
(1)corePoolSize：线程池中常驻核心线程数
(2)maximumPoolSize：线程池能够容纳同时执行的最大线程数
(3)keepAliveTime：多余的空闲线程存活时间
(4)unit：keepAliveTime的时间单位
(5)workQueue：任务队列，被提交但尚未执行的任务
(6)threadFactory：表示生成线程池中的工作线程的线程工厂
(7)handler：拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数(maximumPoolSize)时如何拒绝

// 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
// 保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

// 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
// 定长线程池；适用于执行负载重，cpu使用频率高的任务；
// 这个主要是为了防止太多线程进行大量的线程频繁切换，得不偿失；
// 比如同时很多人进行商品秒杀。
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

// 创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

// 创建一个可缓存线程池，如果线程池长度超过处理需要，
// 可灵活回收空闲线程，若无可回收，则新建线程
// 适用于执行大量（并发）短期异步的任务；注意，任务量的负载要轻；
// 比如同时给很多人发送从磁盘读取的消息通知
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

// 分治线程池，线程之间会窃取任务来执行
public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool
        (Runtime.getRuntime().availableProcessors(),
         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
         null, true);
}

ThreadPoolExecutor tp = new ThreadPoolExecutor(3, 5, 2000L,
      TimeUnit.SECONDS, new ArrayBlockingQueue<>(200),
      new ThreadFactory() {
          private AtomicInteger threadNumber = new AtomicInteger(1);
          @Override
          public Thread newThread(Runnable r) {
              return new Thread(r, "money caculate thread: " + threadNumber.getAndAdd(1));
          }
      },
      new ThreadPoolExecutor.CallerRunsPolicy()
);