线程池入门介绍

---

一、为什么要引入线程池？

我们来谈一下线程池的优点：
第一：降低资源消耗，重复利用已创建的线程降低线程创建和销毁造成的消耗
第二：提高响应速度，当任务到达时，直接从线程池中分配空闲的线程可以立即执行任务
第三：提高线程的管理性，线程频繁的创建和销毁不仅消耗系统资源还会降低系统稳定性，我们使用线程池可以进行统一分配、调度和监控。

二、线程池核心参数

首先我们需要清楚创建线程池所需要的基本参数：
1，corePoolSize（核心线程数）
2，runnableTaskQueue（任务队列，使用阻塞队列实现）
3，maximumPoolSize（线程池能容纳线程的最大容量）
4，ThreadFactory（创建线程的工厂）
5，RejectedExecutionHandler（饱和策略）
6，keepAliveTime（线程活动保持时间）
7，TimeUnit（keepAliveTime的时间单位）

我们结合线程池的主要处理流程来看线程池的核心参数的作用

三、线程池的创建方式

ThreadPoolExecutor是线程池的主要实现类，JDK也在Executors中提供了创建多种类型的线程池模板方法。
由于Executors中的模板方法也是调用ThreadPoolExecutor的构造器实现的，所以我们通过介绍Executors中的模板方法来顺便了解ThreadPoolExecutor创建线程池的方式。

Executors中常见的模板方法：

• FixedThreadPool，固定线程数量的线程池
  适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景，它适用于负载比较重的服务器。

public static ExecutorService newFixedThreadPool(int nThreads) {
		//可以看到Fixed的核心线程数和最大线程数都是传入的参数nThread，
		//而且可以看到这里设置的keepAliveTime为0L，即多余的空闲线程会被立即终止
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

• SingleThreadPool，只有一个线程的线程池
  适用于需要保证顺序的执行各个任务；并且在任意时间点，不会有多个线程的应用场景

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

• CachedThreadPool，大小无界的线程池
  适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器

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

Executors提供的每种生成线程池的方法又根据参数列表的不同进行了重载：
1，不带ThreadFactory参数的（上述展示的）
2，带ThreadFactory参数的，将使用默认的线程工厂生产线程（以CachedThreadPool为例）

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

Executors模板方法（缺点）分析：
（1）对于使用Executors创建的FixedThreadPool，SingleThreadPool，可以看到这两种线程池使用的都是LinkedBlockingQueue的无参构造器来创建任务队列，而在内部又调用了LinkedBlockingQueue的有参构造器，指定队列容量Integer.MAX_VALUE,相当于使用的是无界队列。

使用无界队列充当工作队列的影响
（1）当线程池中的线程数达到corePoolSize后，新任务将在无界对类中等待，因此线程池中的线程数不会超过corePoolSize。
（2）由于线程数不会超过corePoolSize这就到导致了maximumPoolSize相当于是一个无效参数。
（3）由于线程数不会超过corePoolSize和maximumPoolSize是无效参数，就导致了keepAliveTime将是一个无效参数（那么TimeUnit也就成了无效参数）。
（4）无界队列那么也意味着永远不会触发“饱和策略”

public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

（2）对于第三种CachedThreadPool它指定的最大线程数是Integer.MAX_VALUE,这意味着当CachedThreadPool处理任务的速度小于主线程给他提交任务的速度时，CachedThreadPool会不断的创建线程，极端情况下CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源，我们也不建议使用。
（3）我们可以看到其实在Executors类中的这些模板方法中都调用了ThreadPoolExecutor的不带ThreadFactory和RejectedExecutionHandler的构造方法来创建线程池，在这种构造方法内部又调用了重载的同名方法，使用默认的线程工厂和默认的饱和策略填充。

//在Executors的模板方法中调用的ThreadPoolExecutor的（带五个参数，没有ThreadFactory和RejectedExecutionHandler）构造器
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
//最终调用的ThreadPoolExecutor的（全参）构造器
 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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

而且可以看出通过Executors的模板方法创建出来的线程池他们的饱和策略全都是defaultHandler=AbortPolicy（），直接拒绝执行并抛出异常的这种策略。

    //ThreadPoolExecutor中的默认“饱和策略”
private static final RejectedExecutionHandler defaultHandler =
        new 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());
        }
    }

总结

所以综上所述，不建议使用Executors提供的模板方法创建线程池。
建议我们直接使用ThreadPoolExecutors来构建适合当前环境的线程池