ThreadPoolExecutor——线程销毁

面试官:知道线程池吗

我:知道啊,然后准备回答,线程池原理及实现流程

面试官打断:最近面试人挺多的,基本都知道原理,你给我讲讲keepAliveTime具体是怎样实现非核心线程过期回收的。

我:.....(黑人问号)

面试完,迫不及待的打开源码后,发现之前看源码已经看过线程过期后怎样销毁的,但主要是想弄懂线程复用的原理,所以没有注意。

前文源码学习:Java并发包中的线程池ThreadPoolExecutor

一、线程过期销毁

 1、Worker.run():线程池线程复用的原理

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); //将state设置为0,允许中断 allow interrupts
        boolean completedAbruptly = true;
        try {
            //这里就是线程复用的实质,线程执行完提交的任务后,会不停从阻塞队列workerQueue中获取任务再执行
//跳出这里的循环,线程就不会复用,执行完runWorker方法后会被销毁
while (task != null || (task = getTask()) != null) { w.lock();//worker不可重入独占锁 // 如果线程池正在停止Stopping,确保线程中断 // 如果没有,确保线程没有被中断 // 第二种情况需要复查处理 // 清除中断时立即停止比赛 if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { //执行任务前操作--空方法预留扩展 beforeExecute(wt, task); Throwable thrown = null; try { //实际的任务运行command.run() task.run(); } catch (RuntimeException x) { thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { //执行任务后操作--空方法预留扩展 afterExecute(task, thrown); } } finally { task = null; //当前线程完成任务数更新++ w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { //执行清理工作, //将当前线程完成任务数累加到总任务数上 //从workerSet中删除当前工作线程 //尝试终止线程池 //如果当前线程个数小于核心个数,创建线程 processWorkerExit(w, completedAbruptly); } }

2、线程过期销毁

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        //开始执行前会将work.firstTask = null,核心线程、非核心线程都是
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //一次循环后task == null,所以线程过期销毁判断关键在于getTask()
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    //一次循环后task = null
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

ThreadPoolExecutor.getTask()

 private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
//如果工作队列为空,线程池线程数减1,并返回null decrementWorkerCount();
return null; } int wc = workerCountOf(c); //worker工作线程会不会被回收
//① allowCoreThreadTimeOut == true,核心线程和非核心线程空闲keepAliveTime被销毁,workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)
//② allowCoreThreadTimeOut == false,非核心线程空闲keepAliveTIme销毁,workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)
// ,核心线程会被阻塞,不会被销毁workQueue.take()
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) return null; continue; } try { Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }

所以keepAliveTime具体是怎样实现非核心线程过期销毁的,是个很简单的问题。有点后悔没答上来

workQueue队列为空,跳出循环,线程就会被销毁。具体代码通过阻塞队列workQueue(keepAliveTime,TimeUnit.NANOSECONDS)实现控制线程存活时间的

线程销毁的两种场景:

① allowCoreThreadTimeOut == true,核心线程和非核心线程空闲keepAliveTime时被销毁,workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)
② allowCoreThreadTimeOut == false,非核心线程空闲keepAliveTIme时被销毁,workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)

核心线程永不销毁的场景

① allowCoreThreadTimeOut == false,核心线程永不销毁。workQueue.take()阻塞当前线程。

posted on 2020-03-28 21:17  FFStayF  阅读(2336)  评论(0编辑  收藏  举报