线程池的定义

• 减少资源创建 => 减少内存开销，创建线程占用内存
• 降低系统开销 => 创建线程需要时间，会延迟处理的请求
• 提高稳定稳定性 => 避免无限创建线程引起的OutOfMemoryError【简称OOM】

Executors 创建线程池的方法

• 创建返回ThreadPoolExecutor对象
• 创建返回ScheduleThreadPoolExecutor对象(创建定时任务线程池，继承ThreadPoolExecutor)
• 创建返回ForkJoinPool对象(主要特点是分而治之，适合计算密集型大量数据计算)

ThreadPoolExecutor 构造方法

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

参数说明：
corePoolSize => 线程池核心线程数量
maximumPoolSize => 线程池最大数量
keepAliveTime => 空闲线程存活时间
unit => 时间单位
workQueue => 线程池所使用的缓冲队列
threadFactory => 线程池创建线程使用的工厂
handler => 线程池对拒绝任务的处理策略

Executors创建返回ThreadPoolExecutor对象

• Executors#newCachedThreadPool => 创建可缓存的线程池

• Executors#newSingleThreadExecutor => 创建单线程的线程池

• Executors#newFixedThreadPool => 创建固定长度的线程池

• FixedThreadPool和SingleThreadExecutor => 缓存队列使用的是LinkedBlockingQueue，所以允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而引起OOM异常

• CachedThreadPool => 允许创建的线程数为Integer.MAX_VALUE，可能会创建大量的线程，从而引起OOM异常
  这就是为什么禁止使用Executors去创建线程池，而是推荐自己去创建ThreadPoolExecutor的原因

阿里为什么禁止使用Executor去创建线程池

Java线程池拒绝策略

在ThreadPoolExecutor 类中内置了多个拒绝策略。具体策略可以直接查看API。
要想自定义拒绝策略，需要实现如下接口：

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

当触发拒绝策略时，线程池会调用你设置的具体的策略，将当前提交的任务以及线程池实例本身传递给你处理，具体作何处理，不同场景会有不同的考虑。
参考文档：
线程池拒绝策略

假设我们有一个线程池，核心线程数为10，最大线程数也为20，任务队列为100。现在来了100个任务，线程池里现在有几个线程运行?

答案：不一定！因为并没指明是哪一种线程池机制
有2种可能。

• 先进队列，到最大值,再起线程
  JDK中的线程池，即ThreadPoolExecutor就是这种机制
  源码如下：

 int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);

图解

按照这个流程，当有100个任务添加进来时，剩下先起10个核心线程，剩下90个任务都丢进队列里，因此线程池里只有10个线程在执行！

• 先起线程，到最大值,再进队列

我们可以定义子类实现BlockingQueue 接口，重写offer方法。则当100个任务添加进来时，直接会起20个线程，剩下80个任务都丢进队列！
参考链接：线程池使用策略

如何设置线程池参数大小

线程池的线程数量设置过多会导致线程竞争激烈
如果线程数量设置过少的话，还会导致系统无法充分利用计算机资源

Java 通过用户线程与内核线程结合的 1:1 线程模型来实现，Java 将线程的调度和管理设置在了用户态，提供了一套 Executor 框架来帮助开发人员提高效率。Executor 框架不仅包括了线程池的管理，还提供了线程工厂、队列以及拒绝策略等，可以说 Executor 框架为并发编程提供了一个完善的架构体系。
在不同的业务场景以及不同配置的部署机器中，线程池的线程数量设置是不一样的。
其设置不宜过大，也不宜过小，要根据具体情况，计算出一个大概的数值，再通过实际的性能测试，计算出一个合理的线程数量。
我们要提高线程池的处理能力，一定要先保证一个合理的线程数量，也就是保证 CPU 处理线程的最大化。在此前提下，我们再增大线程池队列，通过队列将来不及处理的线程缓存起来。在设置缓存队列时，我们要尽量使用一个有界队列，以防因队列过大而导致的内存溢出问题

• 如果是CPU密集型应用，则线程池大小设置为N+1
• 如果是IO密集型应用，则线程池大小设置为2N+1

结论：线程等待时间所占比例越高，需要越多线程。线程CPU时间所占比例越高，需要越少线程。


服务器性能IO优化 中发现一个估算公式：
最佳线程数目 = （（线程等待时间+线程CPU时间）/线程CPU时间 ）* 
CPU数目

一个系统最快的部分是CPU，所以决定一个系统吞吐量上限的是CPU。增强CPU处理能力，可以提高系统吞吐量上限。但根据短板效应，真实的系统吞吐量并不能单纯根据CPU来计算。那要提高系统吞吐量，就需要从“系统短板”（比如网络延迟、IO）着手：

• 尽量提高短板操作的并行化比率，比如多线程下载技术
• 增强短板能力，比如用NIO替代IO

是否使用线程池就一定比使用单线程高效呢？

答案是否定的，比如Redis就是单线程的，但它却非常高效，基本操作都能达到十万量级/s。从线程这个角度来看，部分原因在于：

• 多线程带来线程上下文切换开销，单线程就没有这种开销
• 锁

当然“Redis很快”更本质的原因在于：Redis基本都是内存操作，这种情况下单线程可以很高效地利用CPU。而多线程适用场景一般是：存在相当比例的IO和网络操作。

所以即使有上面的简单估算方法，也许看似合理，但实际上也未必合理，都需要结合系统真实情况（比如是IO密集型或者是CPU密集型或者是纯内存操作）和硬件环境（CPU、内存、硬盘读写速度、网络状况等）来不断尝试达到一个符合实际的合理估算值。

参考文档：
如何设置合适的线程池大小
如何合理的预估线程池（该文档给出了一个算法来预估我们需要设计的线程池大小）
如何设置合适的线程池大小2（该文档给出了两本书上的介绍，说了一下那个算法）

ThreadPoolExecutor源码解析

核心源码主要包括三个部分。

• execute(Runnable)方法
  可以参考如下流程图：

  
  

• addWorker(Runnable, boolean)方法
  主要分为三步。第一部分是使用CAS安全的向线程池中添加工作线程数量；第二部分是使用ReentrantLock 来保证创建并添加新的工作线程时的同步；第三部分则是将任务通过安全的并发方式添加到workers中，并启动工作线程执行任务。

• addWorkerFailed(Worker)方法
  这个逻辑比较简单，获取ReentrantLock独占锁，将任务从workers中移除，并且通过CAS将任务的数量减1，最后释放锁。

• 拒绝策略

  
  

在创建线程池时，除了能够传递JDK默认提供的拒绝策略外，还可以传递自定义的拒绝策略。如果想使用自定义的拒绝策略，则只需要实现RejectedExecutionHandler接口，并重写rejectedExecution(Runnable, ThreadPoolExecutor)方法即可。如下代码：

public class CustomPolicy implements RejectedExecutionHandler {

    public CustomPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            System.out.println("使用调用者所在的线程来执行任务")
            r.run();
        }
    }
}

使用如下方式创建线程池。

new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                       60L, TimeUnit.SECONDS,
                       new SynchronousQueue<Runnable>(),
                       Executors.defaultThreadFactory(),
               new CustomPolicy());

参考文档：ThreadPoolExecutor

使用线程池带来的风险