java核心技术-线程池基本原理以及常见面试题

成长的小牛233

已于 2023-08-04 20:45:51 修改

阅读量426

点赞数

分类专栏： # 核心技术 # 基础入门文章标签： java 开发语言

于 2021-01-17 14:02:33 首次发布

本文链接：https://blog.csdn.net/dreamzuora/article/details/112742249

版权

基础入门同时被 2 个专栏收录

151 篇文章 1 订阅

订阅专栏

核心技术

35 篇文章 1 订阅

订阅专栏

文章目录

面试官：能给我讲讲线程池的实现原理？
线程池类继承关系
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博客-面试官：你知道什么是线程池的线程复用原理吗？

成长的小牛233

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
java核心技术-线程池基本原理以及常见面试题

文章目录线程池的实现原理线程池类继承关系ThreadPoolExecutorExecutor四种工具类ScheduledThreadPoolExecutorCompletableFuture用法线程池的实现原理线程池类继承关系ThreadPoolExecutorExecutor四种工具类ScheduledThreadPoolExecutorCompletableFuture用法...
复制链接

扫一扫

专栏目录