通过前几篇文章的学习，大家对多线程应该有些理解了吧，这里附上前三篇文章的链接，还没有看过的小伙伴快去温习吧～～

多线程根底篇入门

线程的生命周期和罕用 APIs

生产者消费者问题

那置信大家也能感触到，其实用多线程是很麻烦的，包含线程的创立、销毁和调度等等，而且咱们平时工作时如同也并没有这样来 new 一个线程，其实是因为很多框架的底层都用到了线程池。

线程池是帮忙咱们治理线程的工具，它保护了多个线程，能够升高资源的耗费，进步零碎的性能。

并且通过应用线程池，咱们开发人员能够更好的把精力放在工作代码上，而不去管线程是如何执行的，实现工作提交和执行的解藕。

本文将从是何、为何、如何的角度来解说线程池：

  1. 线程池是什么
  2. 为什么要用线程池
  3. 怎么用线程池

线程池 Thread Pool

线程池是一种池化的技术，相似的还有数据库连接池、HTTP 连接池等等。

池化的思维次要是为了缩小每次获取和完结资源的耗费，进步对资源的利用率。

比方在一些偏远地区打水不不便的，大家会每段时间把水打过去存在池子里，这样平时用的时候就间接来取就好了。

线程池同理，正是因为每次创立、销毁线程须要占用太多系统资源，所以咱们建这么一个池子来对立治理线程。用的时候从池子里拿，不必了就放回来，也不必你销毁，是不是不便了很多？

Java 中的线程池是由 juc 即 java.util.concurrent 包来实现的，最次要的就是 ThreadPoolExecutor 这个类。具体怎么用咱们下文再说。

线程池的益处

在多线程的第一篇文章中咱们说过，过程会申请资源，拿来给线程用，所以线程是很占用系统资源的，那么咱们用线程池来对立治理线程就可能很好的解决这种资源管理问题。

比方因为不须要创立、销毁线程，每次须要用的时候我就去拿，用完了之后再放回去，所以节俭了很多资源开销，能够进步零碎的运行速度。

而对立的治理和调度，能够正当调配外部资源，依据零碎的当前情况调整线程的数量。

那总结来说有以下 3 个益处：

  1. 升高资源耗费：通过反复利用现有的线程来执行工作，防止屡次创立和销毁线程。
  2. 进步相应速度：因为省去了创立线程这个步骤，所以在拿到工作时，能够立即开始执行。
  3. 提供附加性能：线程池的可拓展性使得咱们能够本人退出新的性能，比如说定时、延时来执行某些线程。

说了这么多，终于到了明天的重点，咱们来看下到底怎么用线程池吧～

线程池的实现

Java 给咱们提供了 Executor 接口来应用线程池。

咱们罕用的线程池有这两大类：

  • ThreadPoolExecutor
  • ScheduledThreadPoolExecutor

它俩的区别呢，就是第一个是一般的，第二个是能够定时执行的。

当然还有其余线程池，比方 JDK 1.7 才呈现的 ForkJoinPool ，能够把大工作宰割成小工作来执行，最初再大一统。

那么工作提交到一个线程池之后，它会经验一个怎么的过程呢？

执行过程

线程池在外部实际上采纳了生产者消费者模型（还不分明这个模型的在文章结尾有改文章的链接）将线程和工作解藕，从而使线程池同时治理工作和线程。

当工作提交到线程池里之后，须要通过以下流程：

  1. 首先它查看外围线程池是否已满。这个外围线程池，就是不论用户量多少线程池始终保护的线程的池子。比如说线程池的总容量最多能装 100 个线程，外围线程池咱们设置为 50，那么就无论用户量有多少，都放弃 50 个线程活着。这个数字当然是依据具体的业务需要来决定的。
  2. 阻塞队列，就是 BlockingQueue ，在生产者消费者这节里提到过。
  3. 最初判断线程池是否已满，就是判断是不是曾经有 100 个线程了，而不是 50 个。
  4. 如果曾经满了，所以不能持续创立线程了，就须要依照饱和策略或者叫做回绝策略来解决。这个饱和策略咱们下文再讲。

ThreadPoolExecutor

咱们次要说下 ThreadPoolExecutor ，它是最罕用的线程池。

这里咱们能够看到，这个类里有 4 个构造方法，点进去认真看，其实前三个都 call 了最初一个，所以咱们只须要看最初一个就好。

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

这里咱们来认真看下这几个参数：

  1. corePoolSize：这个就是上文提到过的外围线程池的大小，在外围里的线程是永远不会就业的。
corePoolSize the number of threads to keep in the pool, even if they are idle, unless {\@code allowCoreThreadTimeOut} is set
  1. maximumPoolSize：线程池的最大容量。
maximumPoolSize the maximum number of threads to allow in the pool
  1. keepAliveTime：存活工夫。这个工夫指的是，当线程池中的线程数量大于外围线程数，这些线程闲着之后，多久销毁它们。
keepAliveTime when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating.
  1. unit：对应下面存活工夫的工夫单位。
unit the time unit for the {\@code keepAliveTime} argument
  1. workQueue：这是一个阻塞队列，其实线程池也是生产者消费者模型的一种，工作 - 相当于生产者，线程 - 相当于消费者，所以这个阻塞队列是用来协调生产和生产的进度的。
workQueue the queue to use for holding tasks before they are executed.
  1. threadFactory：这里用到了工程模式，用来创立线程的。
threadFactory the factory to use when the executor creates a new thread
  1. handler：这个就是回绝策略。
handler the handler to use when execution is blocked because the thread bounds and queue capacities are reached

所以咱们能够通过本人传入这 7 个参数结构线程池，当然了，贴心的 Java 也给咱们包装好了几类线程池能够很不便的拿来应用。

  • newCachedThreadPool
  • newFixedThreadPool
  • newSingleThreadExecutor

咱们具体来看每个的含意和用法。

newCachedThreadPool

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

这里咱们能够看到，

  • 外围线程池数量为 0，也就是它不会永恒保留任何线程；
  • 最大容量是 Integer.MAX_VALUE；
  • 每个线程的存活工夫是 60 秒，也就是如果 1 分钟没有用这个线程就被回收了；
  • 最初用到了同步队列。

它的实用场景在源码里有说：

These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks.

来看怎么用：

public class newCacheThreadPool {    public static void main(String[] args) {        // 创立一个线程池        ExecutorService executorService = Executors.newCachedThreadPool();        // 向线程池提交工作        for (int i = 0; i < 50; i++) {            executorService.execute(new Task());//线程池执行工作        }        executorService.shutdown();    }}

执行后果：

能够很分明的看到，线程 1、2、3、5、6 都很快重用了。

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {    return new ThreadPoolExecutor(nThreads, nThreads,                                  0L, TimeUnit.MILLISECONDS,                                  new LinkedBlockingQueue<Runnable>());}

这个线程池的特点是：

  1. 线程池中的线程数量是固定的，也是咱们创立线程池时须要穿入的参数；
  2. 超出这个数量的线程就须要在队列中期待。

它的实用场景是：

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.
public class FixedThreadPool {    public static void main(String[] args) {        ExecutorService executorService = Executors.newFixedThreadPool(10);        for (int i = 0; i < 200; i++) {            executorService.execute(new Task());        }        executorService.shutdown();    }}

这里我限度了线程池里最多有 10 个线程，哪怕有 200 个工作须要执行，也只有 1-10 这 10 个线程能够运行。

newSingleThreadExecutor

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

这个线程池顾名思义，外面只有 1 个线程。

实用场景是：

Creates an Executor that uses a single worker thread operating off an unbounded queue.

咱们来看下成果。

public class SingleThreadPool {    public static void main(String[] args) {        ExecutorService executorService = Executors.newSingleThreadExecutor();        for (int i = 0; i < 100; i++) {            executorService.execute(new Task());        }        executorService.shutdown();    }}

这里在出后果的时候我可能显著的感觉到有些卡顿，这在前两个例子里是没有的，毕竟这里只有一个线程在运行嘛。

小结

所以在应用线程池时，其实都是调用的 ThreadPoolExecutor 这个类，只不过传递的不同参数。

这里要特地留神两个参数：

  • 一是 workQueue 的抉择，这个就是阻塞队列的抉择，如果要说还得这么一大篇文章，之后有机会再写吧。
  • 二是 handler 的设置。

那咱们发现，在下面的 3 个具体线程池里，其实都没有设定 handler，这是因为它们都应用了 defaultHandler。

/** * The default rejected execution handler */private static final RejectedExecutionHandler defaultHandler =    new AbortPolicy();

在 ThreadPoolExecutor 里有 4 种回绝策略，这 4 种策略都是 implements 了 RejectedExecutionHandler：

  1. AbortPolicy 示意回绝工作并抛出一个异样 RejectedExecutionException。这个我称之为“正式回绝”，比方你面完了最初一轮面试，最终接到 HR 的拒信。
  2. DiscardPolicy 回绝工作但不吭声。这个就是“默拒”，比方大部分公司拒简历的时候都是默拒。
  3. DiscardOldestPolicy 顾名思义，就是把老的工作丢掉，执行新工作。
  4. CallerRunsPolicy 间接调用线程解决该工作，就是 VIP 嘛。

所以这 3 种线程池都应用的默认策略也就是第一种，光明磊落的回绝。

好了以上就是本文的所有内容了。当然线程池还有很多知识点，比方 execute() 和 submit() 办法，线程池的生命周期等等。

但随着浏览量的逐步走低，齐姐意识到了这仿佛有什么误会，所以这篇文章是多线程系列的最初一篇了。

本文已收录至我的 Github 上：https://github.com/xiaoqi6666/NYCSDE，点击浏览原文中转，这个 Github 汇总了我所有的文章和材料，之后也会始终更新和保护，还心愿大家帮忙点个 Star，你们的反对和认可，就是我创作的最大能源！

我是小齐，终生学习者，每天晚上 9 点，云自习室里不见不散！