共计 5524 个字符，预计需要花费 14 分钟才能阅读完成。
通过前几篇文章的学习，大家对多线程应该有些理解了吧，这里附上前三篇文章的链接，还没有看过的小伙伴快去温习吧～～
多线程根底篇入门
线程的生命周期和罕用 APIs
生产者消费者问题
那置信大家也能感触到，其实用多线程是很麻烦的，包含线程的创立、销毁和调度等等，而且咱们平时工作时如同也并没有这样来 new 一个线程，其实是因为很多框架的底层都用到了线程池。
线程池是帮忙咱们治理线程的工具，它保护了多个线程，能够升高资源的耗费，进步零碎的性能。
并且通过应用线程池，咱们开发人员能够更好的把精力放在工作代码上，而不去管线程是如何执行的，实现工作提交和执行的解藕。
本文将从是何、为何、如何的角度来解说线程池：
- 线程池是什么
- 为什么要用线程池
- 怎么用线程池
线程池 Thread Pool
线程池是一种池化的技术，相似的还有数据库连接池、HTTP 连接池等等。
池化的思维次要是为了缩小每次获取和完结资源的耗费，进步对资源的利用率。
比方在一些偏远地区打水不不便的，大家会每段时间把水打过去存在池子里，这样平时用的时候就间接来取就好了。
线程池同理，正是因为每次创立、销毁线程须要占用太多系统资源，所以咱们建这么一个池子来对立治理线程。用的时候从池子里拿，不必了就放回来，也不必你销毁，是不是不便了很多？
Java 中的线程池是由 juc 即 java.util.concurrent 包来实现的，最次要的就是 ThreadPoolExecutor 这个类。具体怎么用咱们下文再说。
线程池的益处
在多线程的第一篇文章中咱们说过，过程会申请资源，拿来给线程用，所以线程是很占用系统资源的，那么咱们用线程池来对立治理线程就可能很好的解决这种 资源管理问题。
比方因为不须要创立、销毁线程，每次须要用的时候我就去拿，用完了之后再放回去，所以节俭了很多资源开销，能够进步零碎的运行速度。
而对立的治理和调度，能够正当调配外部资源，依据零碎的当前情况调整线程的数量。
那总结来说有以下 3 个益处：
- 升高资源耗费：通过反复利用现有的线程来执行工作，防止屡次创立和销毁线程。
- 进步相应速度：因为省去了创立线程这个步骤，所以在拿到工作时，能够立即开始执行。
- 提供附加性能：线程池的可拓展性使得咱们能够本人退出新的性能，比如说定时、延时来执行某些线程。
说了这么多，终于到了明天的重点，咱们来看下到底怎么用线程池吧～
线程池的实现
Java 给咱们提供了 Executor 接口来应用线程池。
咱们罕用的线程池有这两大类：
- ThreadPoolExecutor
- ScheduledThreadPoolExecutor
它俩的区别呢，就是第一个是一般的，第二个是能够定时执行的。
当然还有其余线程池，比方 JDK 1.7 才呈现的 ForkJoinPool，能够把大工作宰割成小工作来执行，最初再大一统。
那么工作提交到一个线程池之后，它会经验一个怎么的过程呢？
执行过程
线程池在外部实际上采纳了生产者消费者模型（还不分明这个模型的在文章结尾有改文章的链接）将线程和工作解藕，从而使线程池同时治理工作和线程。
当工作提交到线程池里之后，须要通过以下流程：
- 首先它查看 外围线程池 是否已满。这个外围线程池，就是不论用户量多少线程池始终保护的线程的池子。比如说线程池的总容量最多能装 100 个线程，外围线程池咱们设置为 50，那么就无论用户量有多少，都放弃 50 个线程活着。这个数字当然是依据具体的业务需要来决定的。
- 阻塞队列，就是
BlockingQueue，在生产者消费者这节里提到过。 - 最初判断线程池是否已满，就是判断是不是曾经有 100 个线程了，而不是 50 个。
- 如果曾经满了，所以不能持续创立线程了，就须要依照 饱和策略 或者叫做 回绝策略 来解决。这个饱和策略咱们下文再讲。
ThreadPoolExecutor
咱们次要说下 ThreadPoolExecutor，它是最罕用的线程池。
这里咱们能够看到，这个类里有 4 个构造方法，点进去认真看，其实前三个都 call 了最初一个，所以咱们只须要看最初一个就好。
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {...}这里咱们来认真看下这几个参数：
- corePoolSize：这个就是上文提到过的 外围线程池 的大小，在外围里的线程是永远不会就业的。
corePoolSize the number of threads to keep in the pool, even if they are idle, unless {\@code allowCoreThreadTimeOut} is set
- maximumPoolSize：线程池的最大容量。
maximumPoolSize the maximum number of threads to allow in the pool
- 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.
- unit：对应下面存活工夫的工夫单位。
unit the time unit for the {\@code keepAliveTime} argument
- workQueue：这是一个阻塞队列，其实线程池也是生产者消费者模型的一种，工作 – 相当于生产者，线程 – 相当于消费者，所以这个阻塞队列是用来协调生产和生产的进度的。
workQueue the queue to use for holding tasks before they are executed.
- threadFactory：这里用到了工程模式，用来创立线程的。
threadFactory the factory to use when the executor creates a new thread
- 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>());
}这个线程池的特点是：
- 线程池中的线程数量是固定的，也是咱们创立线程池时须要穿入的参数；
- 超出这个数量的线程就须要在队列中期待。
它的实用场景是：
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：
AbortPolicy示意回绝工作并抛出一个异样RejectedExecutionException。这个我称之为“正式回绝”，比方你面完了最初一轮面试，最终接到 HR 的拒信。DiscardPolicy回绝工作但不吭声。这个就是“默拒”，比方大部分公司拒简历的时候都是默拒。DiscardOldestPolicy顾名思义，就是把老的工作丢掉，执行新工作。CallerRunsPolicy间接调用线程解决该工作，就是 VIP 嘛。
所以这 3 种线程池都应用的默认策略也就是第一种，光明磊落的回绝。
好了以上就是本文的所有内容了。当然线程池还有很多知识点，比方 execute() 和 submit() 办法，线程池的生命周期等等。
但随着浏览量的逐步走低，齐姐意识到了这仿佛有什么误会，所以这篇文章是多线程系列的最初一篇了。
本文已收录至我的 Github 上：https://github.com/xiaoqi6666/NYCSDE，点击浏览原文中转，这个 Github 汇总了我所有的文章和材料，之后也会始终更新和保护，还心愿大家帮忙点个 Star，你们的反对和认可，就是我创作的最大能源！
我是小齐，终生学习者，每天晚上 9 点，云自习室里不见不散！