栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

剖析JDK1.8 ThreadPoolExecutor(线程池)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

剖析JDK1.8 ThreadPoolExecutor(线程池)

剖析流程思路:

  1. 简要查看类体系图,同时阅读类上源码注释,大致了解该类作用。
  2. 了解该类关键属性,以及构造方法。
  3. 查看类的内部类。简要了解重点的内部类
  4. 剖析类的常用方法。知道线程池是如何处理提交过来的任务,以及知道它是如何达到线程资源重复利用。
  5. 总结
1. 类体系图 & 类作用

可以看到ThreadPoolExecutor是Executor接口下的落地实现。

关于Executor接口是干嘛的,总的来说就一句话:想要达到提交任务和执行任务相分离。比如以前代码是new Thread(runnable).  thread.start().耦合度太高,所以制定Executor接口体系来分离。

类描述:

        ThreadPoolExecutor就是线程池,也叫做线程执行器。在线程池中有5个生命周期,分别为RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED。知道线程的生命周期有利于后续看方法实现,因为在方法实现中会大量判断线程中的状态来做不同的处理手段。

**RUNNING**:表示线程处于运行状态。可接收新任务,并且可以处理任务

**SHUTDOWN**:表示线程进入关闭状态,不允许外部提交任务到线程池,但是会把当前待处理的任务处理完毕,在关闭,俗称优雅的关闭。

**STOP**:表示线程立刻进入关闭状态,既不允许外部提交任务到线程池,同时也不会执行待处理的任务,并且如果当前线程已经有在执行的任务,会中断。

**TIDYING**:表示线程进入终止状态中。当任务全部中断,并且线程数全部停止,也就是为0,线程转换成tidying状态。

**TERMINATED**:表示线程进入终止状态。当terminated() 方法执行的时候,线程进入这个状态,换句话说terminated() 方法相当于遗言。
线程池状态变化顺序如下:

​	RUNNING -> SHUTDOWN:当调用shutdown()时,running切换到shutdown状态。

​	RUNNING -> STOP:当调用shutdownNow()时,running切换到STOP状态。

​	SHUTDOWN -> TIDYING:当阻塞队列为空,并且线程全部停止销毁,转变成tidying

​	STOP -> TIDYING:当池为空时。

​	TIDYING -> TERMINATED:当钩子terminated()方法执行的时候。

 其实源码上的类注释非常的多,我这只是摘出来一个点,目的是帮助后续看方法。其他有兴趣可以去看看。我可以总结一下类上面的注释主要说了啥:

  1.         池化技术的作用
  2.         如何创建线程池(Exectors或者手动指定参数创建)
  3.         池中核心线程的使用和池大小的关系
  4.         池中队列的选择与使用
  5.         池中的拒绝策略的选择
  6.         等等。
类关键字段:

有了前面的线程声明周期状态的了解,我们来看看线程池中的字段以及常量,从而大致可以猜出线程池的想要怎么工作。

// 阻塞队列,用于存放待执行的任务。
private final BlockingQueue workQueue;
// 用于存放当前线程池中所有的工作线程 worker对象
private final HashSet workers = new HashSet();
// 创建线程的工厂
private volatile ThreadFactory threadFactory;
// 支持 awaitTermination 的等待条件
private final Condition termination = mainLock.newCondition();
// 最大线程数
private volatile int maximumPoolSize;
// 核心线程数
private volatile int corePoolSize;
// 锁对象
private final ReentrantLock mainLock = new ReentrantLock();
// 记录同时在池中的最大线程数
private int largestPoolSize;
// 非核心线程的最大空闲时间
private volatile long keepAliveTime;
// 拒绝策略
private volatile RejectedExecutionHandler handler;
// 默认的拒绝策略
private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
// 完成任务的计数
private long completedTaskCount;
// 是否允许核心线程超时,如果true,则核心线程空闲的时候也会进入等待时间,超过就销毁。
private volatile boolean allowCoreThreadTimeOut;

// ctl 主池控制状态。 如果通过wockerCount()方法计算它,则表示:计算当前工作线程的数量
//					如果通过runState()方法计算它,则表示:获取当前线程池的运行状态。
// 	线程池的运行状态如下5个变量所示:
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
    // 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;

private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");
private static final boolean ONLY_ONE = true;

 类的构造器:
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;
    }

通过上面字段的认识,现在看它的构造器一点都不陌生,就是对一些字段的初始化。比如初始化核心线程,最大线程,以及线程的空闲等待时间,池采用哪种组设队列来存储任务,以及采取那种拒绝策略等。

在往下我们就简要看看内部类,从而过渡到它的整个工作原理。

类中内部类:

 4个拒绝策略和一个工作线程Worker。

拒绝策略:
public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

 这是拒绝策略的接口定义,四个拒绝策略都是实现了这个接口,重写了拒绝方式。所以如果默认的4个拒绝策略不满足你的需求,你可以自定义实现这个接口,编写自己的拒绝策略。

  • AbortPolicy:拒绝本次任务,并且抛出一个异常

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    throw new RejectedExecutionException("Task " + r.toString() +
                                         " rejected from " +
                                         e.toString());
}
  • DiscardPolicy:拒绝本次任务,但是不抛出异常

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {}
  • DiscardOldestPolicy:丢弃最老的任务,并且重试execute,即将任务重试提交。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        e.getQueue().poll();
        e.execute(r);
    }
}
  • CallerRunsPolicy:直接让调用者线程执行该任务。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        r.run();
    }
}
Woker:线程池中的工作者线程
 private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        private static final long serialVersionUID = 6138294804551838833L;

        final Thread thread;
        Runnable firstTask;
        volatile long completedTasks;

        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        public void run() {
            runWorker(this);
        }
        protected boolean isHeldExclusively() {
            return getState() != 0;
        }

        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

可以看到worker其实就是一个Runnable,重写了run方法,最终运行任务,走的是runworker(this).同时类里面还extends AQS,有一些AQS相关的,但是无关紧要,它不在本文章中。我们可以忽略,只要记住worker是一个runnable类型,任务提交到线程池,会被包装成worker去运行即可。

看到此处,我们都有一些印象线程池内部都有哪些字段,以及它的工作者线程worker了。现在我们就可以去看方法实现原理了。

 

类常用方法解析:

此刻,我们就从代码角度走一下线程池的工作流程:

1.当执行execute(runnable) 即 提交任务到线程。

execute执行3步骤:

        1.如果核心线程数没满,则在创建一个核心线程跑这个任务,---》程序结束。

        2.核心满了,则将任务入队,入队后需要再次检测线程池状态,因为有可能池关闭了,如果关闭则从任务队列中回滚这个任务。如果池没关闭,则进一步检测是否有工作线程(因为有可能现有的线程自上次检测后就死了),如果没有,开启一个。 ---》程序结束

        3.如果不能入队,再次尝试启动一个非核心线程,如果失败,说明线程池达到饱和状态,采取拒绝策略。---》程序结束。

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    
    // 1. 检测线程池状态核心线程状态数 & 可否再次开启一个核心线程 
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    
    // 2. 判断线程池状态 & 尝试入队
    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);
    }
    
    // 3. 入队失败,继续尝试一次开启非核心线程,如果失败,采取拒绝
    else if (!addWorker(command, false))
        reject(command);
}

 execute方法执行的这3步骤就是面试时常常问的线程池的工作原理或者叫工作流程,总结起来就是上面的步骤:

        当任务提交到线程池的时候,首先会判断核心线程数是否达到上限,如果没有,则新开启一个核心线程提供本次的任务。

        如果核心线程数已经达到上限,那么会尝试将任务加入到阻塞队列中,入队成功会再次判断线程池的状态,如果关闭了,就执行队列回滚,并且采用拒绝策略拒绝本次的任务。或者如果入队成功,但是线程池没有工作线程,就会开启一个非核心线程。

        如果入队都失败了,那么就说明阻塞队列是满的,直接开启一个非核心线程提供服务。

        如果非核心线程也开启失败了,我们就知道线程池线程数量已经达到饱和状态,就采取拒绝策略拒绝本次任务。

        最后非核心线程处理完毕任务后,会进入一个最大等待时间,超过这个时间没有接收到任务,就会进入销毁阶段。(这个知识点后面才会看到)

2.addWorker(Runnable firstTask, boolean core):给线程池增加一个工作线程。(core来判断是否核心)

        检测是否可以根据线程池的状态和边界 给线程池添加一个新的工作线程,如果可以,线程数量会得到更新,并且firstTask会作为新工作线程的首个任务。如果池已经停止或者无法创建新线程则return false。创建线程失败无非两种情况:1、线程工厂return null,2.由于异常(通常是thread.start() 抛出oom)我们就干净利落的回滚。

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // 1. 检测线程池状态
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
            // 1. 检测线程池的线程数量的边界
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            
            // 程序能执行到此处,说明可以添加一个新线程就利用cas操作将wokerCount值+1
            if (compareAndIncrementWorkerCount(c))
                break retry;
            
            // cas失败,自旋重试
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 2.创建一个新woker者,将firstTask作为它的首个任务。
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                
                int rs = runStateOf(ctl.get());

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    
                    // 添加工作者到wokers集合中,并且维护当前所有工作者个数。
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 启动新线程
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        // 新工作线程创建失败,执行回滚。
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

worker一旦添加,那么最终cpu调度的时候执行的肯定是worker中的run方法。来看下。

worker工作者者的run方法直接调用runWoker。目标来到runWorker,看工作者线程如何工作。

public void run() {
    runWorker(this);
}
3. runWorker(Worker w):运行工作者线程

看代码之前先阅读该方法的说明。

工作线程主要任务,反复从队列中获取任务并且执行,同时处理一些问题:

  1. 运行首个任务,运行完毕,通过getTask再次获取一个任务运行。如果getTask返回null,则worker根据池状态或配置参数而退出。
  2.  运行任何一个任务之前,尝试获取锁,以防止在任务执行时其他池中断。然后我们确保除非池正在停止,否者线程没有中断集。
  3. 每个任务在运行之前都会执行beforeExecute,这可能会导致异常,这种情况下,我们会让线程死亡而不处理任务。
  4. 假设beforeExecute正常执行,没有抛出异常,那么我们将执行任务,在执行任务中收集它抛出的任何异常以发送到afterExecute。我们分别处理 RuntimeException、Error和任意 Throwables。因为我们不能在 Runnable.run 中重新抛出 Throwable,所以我们在出路时将它们包装在 Errors 中(到线程的 * UncaughtExceptionHandler)。任何抛出的异常也保守的导致线程死亡。
  5. 任务执行完毕后,执行afterExecute,afterExecute也可能引发异常,同样也会导致线程死亡。
  6. 异常机制的最终效果是 afterExecute和线程的 UncaughtExceptionHandler 具有尽可能准确的信息,因为我们可以提供有关用户代码遇到的任何问题的信息。
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 循环获取任务,并且执行,通过getTask().直到getTask() 返回null
        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
                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,并且传递收集到的异常
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // worker退出while,为垂死的工人进行清理和记账
        processWorkerExit(w, completedAbruptly);
    }
}

那么通过以上注释以及代码,我们清晰的知道,原来线程池中的worker工作者,会先将当前首任务跑完,然后循环去阻塞队列中获取任务在执行,直到获取返回null,才死亡!那么重点就来到getTask()方法呗,看worker是如何去阻塞队列中获取新任务的。

getTask(): 从阻塞队列中获取一个任务,获取不到return null

woker工作者在从阻塞队列中获取任务,获取不到执行阻塞 或者 定时等待任务,具体取决于配置设置,或者如果此woker工作者由于以下任何原因必须退出,则return null:

  • 线程池超过maximumPoolSize 个工人

  • 线程池进入stop状态

  • 线程池进入shutdown状态 并且 阻塞队列为空

  • 当前worker超时等待任务

通过上一个runWorker方法,我们知道一旦return null该worker 就会进入销毁阶段。

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

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

        // 线程池进入shutdown状态 并且 阻塞队列为空 则 将 worketCount-1. 同时return null
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        // 获取当前线程池中的工作者线程数量
        int wc = workerCountOf(c);

        
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            // 通过timed来区分核心还是非核心
            // 如果非核心,则调用阻塞队列的poll并且带上超时时间
            // 如果核心,则调用组设队列的take方法,而take组设式等待,每获取到任务,就阻塞调用者线程。
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

        通过此getTask方法,可以看到其实就是通过wc(当前线程池的工作线程数) 是否大于corePoolSize,如果大于,则说明当前worker是一个非核心,那么就调用阻塞队列的poll()并且携带上超时时间,否者调用take()。而poll方法超过时间每获取到任务,则reutn null,一旦return null,那么当前worker就会进入销毁。而take方法是阻塞式等待,获取不到任务,则阻塞当前worker。从而保证线程池中始终有那么几个核心线程数没有销毁。

总结:

        ThreadPoolExecutor这个类重要的就是构造方法上的7大参数,整个线程池的运行原理都是围绕着7大参数来执行。 另外读完ThreadPoolExecutor类要知道线程池的整个工作流程,以及核心线程数是如何不被销毁的。这两个知识点在面试时命中率非常高。

        最后还有一些知识点可以去扩展学习,就是线程池该如何正确配置7大参数,以及阻塞队列的实现原理(重点剖析一个一般就差不多了),还有一开始看到的AQS,后续也可以看看。看完AQS,才可以去理解后续的JUC包下的锁等。

补充:

        如果文章中哪些错误!欢迎大神指出!本人刚毕业入行,希望能够得到前辈的指点与批评!

        

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/970393.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号