文章目录
- 面试官:能给我讲讲线程池的实现原理?
- 线程池类继承关系
- ThreadPoolExecutor
- ScheduledThreadPoolExecutor
- CompletableFuture用法
- 有哪 6 种常见的线程池?什么是 Java8 的 ForkJoinPool?
面试官:能给我讲讲线程池的实现原理?
声:回答该问题需要了解线程池有哪些方法并讲解每个方法的作用,以及各个类的继承关系,线程池的运行原理,线程池的状态转换、生命周期,线程池的构造参数,线程池Runnable->Worker->Thread执行任务->线程复用机制等
线程池类继承关系
ThreadPoolExecutor
核心数据结构
public class ThreadPoolExecutor extends AbstractExecutorService {
//存储线程池的状态和线程数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 存放任务的阻塞队列
private final BlockingQueue<Runnable> workQueue;
// 对线程池内部各种变量进行互斥访问控制
private final ReentrantLock mainLock = new ReentrantLock();
// 线程集合
private final HashSet<Worker> workers = new HashSet<Worker>();
每一个线程是一个Worker对象,Worker是ThreadPoolExecutor内部类,核心数据结构如下:
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
final Thread thread; // Worker封装的线程
Runnable firstTask; // Worker接收到的第1个任务
volatile long completedTasks; // Worker执行完毕的任务个数
}
由定义会发现,Worker继承于AQS,也就是说Worker本身就是一把锁。这把锁有什么用处呢?用于线程池的关闭、线程执行任务的过程中。
面试官:给我讲讲线程池的有哪些参数?
ThreadPoolExecutor在其构造方法中提供了几个核心配置参数,来配置不同策略的线程池。
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
- corePoolSize:核心线程数-线程池中始终维护的线程
- MaxPoolSize:最大线程数-达到核心线程数并且阻塞队列慢的时候会扩充到最大线程数
- KeepAliveTime、TimeUnit:空闲超过该时间后线程会被销毁
- WorkQueue:任务阻塞队列-当核心线程满的时候会放入阻塞队列中
- ThreadFactory:线程工厂-可以根据业务自定义创建线程,修改线程名称
- Handler:拒绝策略-最大线程满并且阻塞队列慢了之后新的任务进来会触发拒绝策略
面试官:如何优雅的关闭线程?
线程池的关闭比线程的关闭更加复杂,因为线程池的关闭涉及到很多场景,如果有线程正在执行任务?如果任务队列不为空?还有当前线程进来如何处理,因此,关闭过程不可能是瞬时的,而是需要一个平滑的过渡,这就涉及线程池的完整生命周期管理。
线程的生命周期
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
在JDK 7中,把线程数量(workerCount)和线程池状态(runState)这两个变量打包存储在一个字
段里面,即ctl变量。如下图所示,最高的3位存储线程池状态,其余29位存储线程个数。而在JDK 6中,
这两个变量是分开存储的。
关于内部封装的获取生命周期状态、获取线程池线程数量的计算方法如以下代码所示
private static int runStateOf(int c) { return c & ~CAPACITY; } //计算当前运行状态
private static int workerCountOf(int c) { return c & CAPACITY; } //计算当前线程数量
private static int ctlOf(int rs, int wc) { return rs | wc; } //通过状态和线程数生成ctl
面试官:ctl为什么这样设计?这样做的好处?
用一个变量去存储两个值,可避免在做相关决策时,出现不一致的情况,不必为了维护两者的一致,而占用锁资源。通过阅读线程池源代码也可以发现,经常出现要同时判断线程池运行状态和线程数量的情况。线程池也提供了若干方法去供用户获得线程池当前的运行状态、线程个数。这里都使用的是位运算的方式,相比于基本运算,速度也会快很多。
线程状态转换过程:
状态解释:
切记:线程状态-1、0、1、2、3转化只能从小到大,而不能逆向转换。
除 terminated()之外,线程池还提供了其他几个钩子方法,这些方法的实现都是空的。如果想实现
自己的线程池,可以重写这几个方法:
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }
protected void terminated() { }
面试官:线程池哪五种状态?
// runState is stored in the high-order bits
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
面试官:线程池哪4种拒绝策略?并分别说一下作用和实现原理?
接口类:
public interface RejectedExecutionHandler {
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
实现类:
DiscardOldestPolicy
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
/**
* 从任务队列中调用poll()方法删除最先入队列的(最老的)任务
* 拓展:队列是先进先出,由此调用poll()方法是取出的是先入队列的数据
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
AbortPolicy
public static class AbortPolicy implements RejectedExecutionHandler {
/**
* Creates an {@code AbortPolicy}.
*/
public AbortPolicy() { }
/**
* Always throws RejectedExecutionException.
* 丢弃准备添加的任务并抛出异常
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
* @throws RejectedExecutionException always
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
DiscardPolicy
public static class DiscardPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardPolicy}.
*/
public DiscardPolicy() { }
/**
* Does nothing, which has the effect of discarding task r.
* 不做任何处理,丢弃准备添加的任务
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
CallerRunsPolicy
public static class CallerRunsPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code CallerRunsPolicy}.
*/
public CallerRunsPolicy() { }
/**
* Executes task r in the caller's thread, unless the executor
* has been shut down, in which case the task is discarded.
* 准备添加的任务,直接调用run()方法交给提交任务的线程执行
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
面试官:线程池常用的阻塞队列有哪些?能说下各自的区别?
队列 | 说明 |
---|---|
ArrayBlockedQueue | 数组实现有界队列,FIFO先入先出,支持公平锁、非公平锁 |
LinkedBlockedQueue | 单链表实现的有界队列,如果不指定容量默认为Integer.MAX_VALUE |
SynchronousQueue | 不存储元素的队列,每个put()操作时必须有线程正在调用take(),该元素才存在,Executors.newCacheThreadPool()就使用该队列,每来一个任务如果没有空闲线程(线程复用)则创建新线程执行任务 |
PriorityBlockedQueue | 无界的优先队列,默认按自然排序,自定义实现compareTo()定制自己优先级,不同保证同优先级顺序 |
DelayQueue | 无界延迟队列,利用PriorityBlockedQueue实现,在创建元素时可以指定多久能够获取到该元素,只有满足延迟时间才能获取到数据,ScheduledThreadPoolExecutor定时任务就是利用自己实现的延时队列(思想一致) |
SynchronousQueue应用
@Test
public void SynchronousQueue() throws InterruptedException {
SynchronousQueue<Integer> queue = new SynchronousQueue<>();
Random random = new Random();
AtomicInteger ait = new AtomicInteger(0);
new Thread(() -> {
try {
for (int i = 0; i < 3; i++) {
Integer integer = queue.take();
if (integer != null){
int count = ait.incrementAndGet();
System.out.println(count + "-" + integer);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(3);
new Thread(() -> {
for (int i = 0; i < 3; i++) {
queue.offer(random.nextInt());
}
}).start();
TimeUnit.SECONDS.sleep(5);
}
PriorityBlockedQueue应用
和PriorityQueue使用一样,无非就是加了锁阻塞生产、消费者线程
@Test
public void priorityQueue(){
PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
});
queue.add(2);
queue.add(1);
queue.add(3);
while (!queue.isEmpty()){
System.out.println(queue.poll());
}
PriorityQueue<CustomRank> queue2 = new PriorityQueue<>();
queue2.add(new CustomRank(2));
queue2.add(new CustomRank(1));
queue2.add(new CustomRank(3));
while (!queue2.isEmpty()){
System.out.println(queue2.poll().v);
}
}
public class CustomRank implements Comparable<CustomRank>{
Integer v;
public CustomRank(Integer v) {
this.v = v;
}
@Override
public int compareTo(CustomRank o) {
return Integer.compare(this.v, o.v);
}
}
DelayQueue应用
@Test
public void delayQueue() throws InterruptedException {
DelayQueue<CustomTimeTask> queue = new DelayQueue<>();
queue.add(new CustomTimeTask("我是第一个任务", 4, TimeUnit.SECONDS));
queue.add(new CustomTimeTask("我是第二个任务", 8, TimeUnit.SECONDS));
queue.add(new CustomTimeTask("我是第三个任务", 16, TimeUnit.SECONDS));
while (!queue.isEmpty()){
CustomTimeTask task = queue.take();
System.out.format("name: {%s}, time: {%s} \n", task.name, new Date());
}
}
class CustomTimeTask implements Delayed{
//触发时间
long time;
//任务名称
String name;
public CustomTimeTask(String name,long time, TimeUnit timeUnit) {
this.time = System.currentTimeMillis() + timeUnit.toMillis(time);
this.name = name;
}
@Override
public long getDelay(TimeUnit unit) {
return time - System.currentTimeMillis();
}
/**
* 利用优先队列将任务按照触发时间从小到大排序
* @param o
* @return
*/
@Override
public int compareTo(Delayed o) {
CustomTimeTask other = (CustomTimeTask) o;
return Long.compare(this.time, other.time);
}
@Override
public String toString() {
return "CustomTimeTask{" +
"time=" + time +
", name='" + name + '\'' +
'}';
}
}
面试官:如何结合业务合理的配置线程池参数?CPU密集型和IO密集型如何配置?线程设置过多会造成什么影响?
答案:其实没有完整的公式去计算,我在使用的时候一般是根据业务场景,动态的去改变线程池参数选择最优配置方案
CPU 密集型任务
IO密集型任务
面试官:给我讲讲什么是线程复用?
什么是线程复用?
通过同一个线程去执行不同的任务,这就是线程复用。
java.util.concurrent.ThreadPoolExecutor#execute
public void execute(Runnable command) {
// 如果传入的Runnable的空,就抛出异常
if (command == null)
throw new NullPointerException();
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);
}
线程复用源码分析:java.util.concurrent.ThreadPoolExecutor#runWorker
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // 释放锁 设置work的state=0 允许中断
boolean completedAbruptly = true;
try {
//一直执行 如果task不为空 或者 从队列中获取的task不为空
while (task != null || (task = getTask()) != null) {
task.run();//执行task中的run方法
}
}
completedAbruptly = false;
} finally {
//1.将 worker 从数组 workers 里删除掉
//2.根据布尔值 allowCoreThreadTimeOut 来决定是否补充新的 Worker 进数组 workers
processWorkerExit(w, completedAbruptly);
}
}
面试官:为什么《阿里巴巴开发手册》不推荐使用Executor创建线程?
ScheduledThreadPoolExecutor
延时执行
schedule
周期执行
1.scheduleAtFixedRate方法
按固定频率执行,与任务本身执行时间无关。但有个前提条件,任务执行时间必须小
于间隔时间,例如间隔时间是5s,每5s执行一次任务,任务的执行时间必须小于5s。
2.scheduleWithFixedDelay方法
按固定间隔执行,与任务本身执行时间有关。例如,任务本身执行时间是10s,
间隔2s,则下一次开始执行的时间就是12s
面试题:如何实现的延迟执行任务和周期性执行任务的呢?
ScheduledThreadPoolExecutor继承了ThreadPoolExecutor,这意味着其内部的数据结构和ThreadPoolExecutor是基本一样的。
延迟执行任务依靠的是DelayQueue。DelayQueue是 BlockingQueue的一种,其实现原理是二叉堆。
而周期性执行任务是执行完一个任务之后,再把该任务扔回到任务队列中,如此就可以对一个任务反复执行。
不过这里并没有使用DelayQueue,而是在ScheduledThreadPoolExecutor内部又实现了一个特定的DelayQueue。
延迟执行设计原理:
和schedule(…)方法的框架基本一样,也是包装一个ScheduledFutureTask对象,只是在延迟时间参数之外多了一个周期参数,然后放入DelayedWorkerQueue就结束了。
两个方法的区别在于一个传入的周期是一个负数,另一个传入的周期是一个正数,为什么要这样做呢?
用于生成任务序列号的sequencer,创建ScheduledFutureTask的时候使用:
周期性执行设计原理:
面试题:为什么不使用Timer而使用ScheduledThreadPoolExecutor?
CompletableFuture用法
有哪 6 种常见的线程池?什么是 Java8 的 ForkJoinPool?
本课程内容参考:
1.《并发编程78讲》-徐隆曦 滴滴出行高级工程师
2.美团技术博客-Java线程池实现原理及其在美团业务中的实践
3.《java并发编程实战》
4.CSDN博客-面试官:你知道什么是线程池的线程复用原理吗?