Java并发编程：线程池 ThreadPoolExector 学习篇
常见大厂面试题型：
- 线程池使用过吗？谈谈对 ThreadPoolExector 的理解？
- 为什使用线程池，线程池的优势？
- 创建线程的几种方式？
- 线程池如何使用？
- 线程池的几个重要参数介绍？
- 说说线程池的底层工作原理？
- 线程池的拒绝策略你谈谈？
- 你在工作中单一的、固定数的和可变的三种创建线程池的方法，你用哪个多？
- 你在工作中是如何使用线程池的，是否自定义过线程池使用？
- 合理配置线程池你是如果考虑的？
带着问题学习，我相信能理解的更深刻，掌握的更多。
一、线程池使用过吗？谈谈对 ThreadPoolExector 的理解？
根据自己学习情况回答。
二、为什使用线程池，线程池的优势？
线程池用于多线程处理中，它可以根据系统的情况，可以有效控制线程执行的数量，优化运行效果。线程池做的工作主要是：控制运行的线程的数量，处理过程中将多余的任务放入阻塞队列，然后创建线程启动这些任务，如果线程数量超过了最大数量，那么超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。
主要特点为：
- 线程复用
- 控制最大并发数量
- 管理线程
主要优点：
- 降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
- 提高相应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅仅会消耗系统资源，还会降低体统的稳定性，使用线程可以进行统一分配，调优和监控。
三、创建线程的几种方式
- 继承 Thread
- 实现 Runnable 接口
- 实现 Callable
举例：Thread 、Runnable就不举例了，下面是通过Callable接口实现：
public class CallableDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 在 FutureTask 中传入 Callable 的实现类
FutureTask futureTask = new FutureTask<>(new Callable() {
@Override
public Integer call() throws Exception {
return 12;
}
});
// 把 futureTask 放入线程中
new Thread(futureTask).start();
// 获取结果
Integer res = futureTask.get();
System.out.println(res);
}
}
四、线程池如何使用？
1、架构说明：
2、编码实现：
常用3种：
- Executors.newSingleThreadExecutor()：只有一个线程的线程池，因此所有提交的任务是顺序执行，适用于一个一个任务执行的场景
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));
}
- Executors.newCachedThreadPool()：线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除，适用执行很多短期异步的小程序或者负载较轻的服务
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L,
TimeUnit.SECONDS, new SynchronousQueue());
}
- Executors.newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务，性能好很多。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
}
不常用：
- Executors.newScheduledThreadPool()：用来调度即将执行的任务的线程池
- Executors.newWorkStealingPool()： newWorkStealingPool适合使用在很耗时的操作，但是newWorkStealingPool不是ThreadPoolExecutor的扩展，它是新的线程池类ForkJoinPool的扩展，但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），所以适合使用在很耗时的任务中
可以发现每种方式的底层最终还是通过ThreadPoolExecutor来实现线程池
ThreadPoolExecutor作为java.util.concurrent包对外提供基础实现，以内部线程池的形式对外提供管理任务执行，线程调度，线程池管理等等服务。
五、线程池的几个重要参数介绍？
ThreadPoolExecutor底层源码，带有7个参数：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue 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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
核心参数：前5个
| 参数 |
作用 |
| corePoolSize |
核心线程池大小 |
| maximumPoolSize |
最大线程池大小 |
| keepAliveTime |
线程池中超过 corePoolSize 数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true) 使得核心线程有效时间 |
| TimeUnit |
keepAliveTime 时间单位 |
| workQueue |
阻塞任务队列 |
| threadFactory |
新建线程工厂 |
| RejectedExecutionHandler |
拒绝策略。当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理 |
六、说说线程池的底层工作原理？
重点讲解：
其中比较容易让人误解的是：参数corePoolSize，maximumPoolSize，workQueue之间关系。
- 当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
- 当线程池达到corePoolSize时，新提交任务将被放入 workQueue 中，等待线程池中任务调度执行。
- 当workQueue已满，且 maximumPoolSize 大于 corePoolSize 时，新提交任务会创建新线程执行任务。
- 当提交任务数超过 maximumPoolSize 时，新提交任务由 RejectedExecutionHandler 处理。
- 当线程池中超过corePoolSize 线程，空闲时间达到 keepAliveTime 时，关闭空闲线程 。
- 当设置allowCoreThreadTimeOut(true) 时，线程池中 corePoolSize 线程空闲时间达到 keepAliveTime 也将关闭。
推荐看juc底层视频学习一下：本人学习教程，尚硅谷周阳线程池详解
七、线程池的拒绝策略你谈谈？
1、什么是拒绝策略：
等待队列已经满了，再也塞不下新的任务，同时线程池中的线程数达到了最大线程数max，无法继续为新任务服务。此时，我们需要拒绝策略机制合理的处理这个问题。也就是七大参数之一：RejectedExecutionHandler
2、拒绝策略有哪些：
- AbortPolicy（默认）：处理程序遭到拒绝将抛出运行时 RejectedExecutionException，阻止系统的正常运行。
- CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度，既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低任务的流量。
- DiscardPolicy：不能执行的任务将被删除，直接丢弃任务
- DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。抛弃队列中等待最久的任务
八、你在工作中单一的、固定数的和可变的三种创建线程池的方法，你用哪个多，超级大坑？
聪明的人的回答应该不是这三者中的任何一个，而是自己创建线程池。如果读者对Java中的阻塞队列有所了解的话，看到这里或许就能够明白原因了。
Java中的BlockingQueue主要有两种实现，分别是ArrayBlockingQueue 和 LinkedBlockingQueue。
ArrayBlockingQueue是一个用数组实现的有界阻塞队列，必须设置容量。
LinkedBlockingQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。
这里的问题就出在：
不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。也就是说，如果我们不设置LinkedBlockingQueue的容量的话，其默认容量将会是Integer.MAX_VALUE。而newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题OOM。
九、你在工作中是如何使用线程池的，是否自定义过线程池使用？
自定义线程池，以及api方式举例：
package com.juc.threadpool;
import java.util.concurrent.*;
/**
* @program: acmPractice
* @description: 线程池应用
* @author: Mr.Li
* @create: 2019-10-09 20:33
**/
public class MyThreadPoolDemo {
public static void main(String[] args) {
//一池5个线程处理
//ExecutorService threadPool = Executors.newFixedThreadPool(5);
//一池一线程
//ExecutorService threadPool = Executors.newSingleThreadExecutor();
//一池n线程
//ExecutorService threadPool = Executors.newCachedThreadPool();
//自定义线程池
ExecutorService threadPool = new ThreadPoolExecutor(2,5,1L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
//4种拒绝策略.AbortPolicy,CallerRunsPolicy,DiscardPolicy,DiscardOldestPolicy
//不同的策略方式，运行结果也将不一致
//模拟10个用户来办理业务，每个用户就是一个来自外部的请求线程
for(int i = 1; i <= 10; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName() + "办理业务");
});
}
}
}
十、合理配置线程池你是如果考虑的？
1、CPU 密集型
- CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
- CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。
2、IO 密集型
- 由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2
- 也可以使用公式：CPU 核数 / (1 - 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。
扩展
十一、死锁编码以及定位分析
产生死锁的原因：
死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种相互等待的现象，如果无外力的干涉那它们都将无法推进下去，如果系统的资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。
代码体现：
package com.juc.deadlock;
import java.util.concurrent.TimeUnit;
/**
* @description: 造成死锁的原因，如何排除
* @author: Mr.Li
* @create: 2019-10-10 15:53
**/
class HoldLockThread implements Runnable {
private String lockA;
private String lockB;
public HoldLockThread(String lockA, String lockB) {
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA) {
System.out.println(Thread.currentThread().getName() + "\t自己持有" + lockA + "尝试获得" + lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB) {
System.out.println(Thread.currentThread().getName() + "\t自己持有" + lockB + "尝试获得" + lockA);
}
}
}
}
public class DeadLockDemo {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
new Thread(new HoldLockThread(lockA,lockB),"AA").start();
new Thread(new HoldLockThread(lockB,lockA),"BB").start();
}
}
运行：程序始终未结束，并不知道发生什么错误
如何排查问题及相应解决：首先转到终端，输入命令 jsp -l 查出对应程序的进程号为 4184
然后输入命令：jstack 4184
可看到结果：发现一处死锁错误
Java stack information for the threads listed above:
===================================================
"BB":
at com.juc.deadlock.HoldLockThread.run(DeadLockDemo.java:30)
- waiting to lock <0x00000000d604bf88> (a java.lang.String)
- locked <0x00000000d604bfc0> (a java.lang.String)
at java.lang.Thread.run(Thread.java:748)
"AA":
at com.juc.deadlock.HoldLockThread.run(DeadLockDemo.java:30)
- waiting to lock <0x00000000d604bfc0> (a java.lang.String)
- locked <0x00000000d604bf88> (a java.lang.String)
at java.lang.Thread.run(Thread.java:748)
Found 1 deadlock.
好了，也到尾声了，感谢你的观看，希望你尽快学会掌握喔！
每日一言：
生活就像海洋，只有一直坚强的人才能到达彼岸