Java并发系列「5」-- Thread 线程池源码解析以及上一章问题解释

最新推荐文章于 2024-11-09 12:43:52 发布

Like Java Long Time

最新推荐文章于 2024-11-09 12:43:52 发布

阅读量1.5k

点赞数 17

分类专栏： Java并发系列文章标签： java 开发语言后端并发

本文链接：https://blog.csdn.net/wenaicoo/article/details/122404021

版权

Java并发系列专栏收录该内容

5 篇文章 8 订阅

订阅专栏

@TOC# Java并发系列
记录在程序走的每一步___auth:huf

大家好，我是老胡。大家来学习并发咯。
今天这一章 可能回稍微有点源码的存在； 
我尽量把这一章简化的讲解；

线程池的任务执行流程；

我先上一段代码：

 ExecutorService HufExecutorService = new ThreadPoolExecutor(10, 15,
                0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(5));

现在这段代码；
核心线程：10；
最大线程：15；
创建队列：5；

这里我先抛一个问题出来，假设我们往这个线程丢任务；连续丢50个我们会在第几个任务触发异常？

放出全部代码：

package com.huf;
import java.util.concurrent.*;

/**
 * @Description TODO
 * @Auth: Huf
 * @Date: 2022/1/7
 **/
public class ThreadTest3 {

    public static void main(String[] args) throws InterruptedException {
        //缓存线程池
        ExecutorService cachedExecutorService = Executors.newCachedThreadPool();
        //核心线程池
        ExecutorService fixedExecutorService = Executors.newFixedThreadPool(10);
        //单例线程池
        ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();
        //自己创建线程池；
        ExecutorService HufExecutorService = new ThreadPoolExecutor(10, 15,
                0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(5));

        for (int i = 0; i < 50; i++) {
            final Integer a = i;
            HufExecutorService.execute(()->{
                function(a);
            });
        }
        //HufExecutorService.shutdown();
    }
    public static void function(Integer a){
        System.out.println(Thread.currentThread().getName()+" 执行了"+ a +"线程");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

在这里插入图片描述
答案是第 21个。为什么？

我们画图了解一下；
在这里插入图片描述
一下是 ExecutorService.execute 因为我们执行这个方法之个方法就是Threadpool 的关键方法；
我们可以继续往深入探查为什么执行顺序会是这样子；

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
		*分三步进行：
		*
		* 1. 如果正在运行的线程少于corePoolSize，请尝试
		*以给定命令作为第一个线程启动新线程
		*任务。对addWorker的调用以原子方式检查运行状态和
		*workerCount，从而防止可能增加
		*在不应该的情况下，通过返回false执行线程。
		*
		* 2. 如果任务可以成功排队，那么我们仍然需要
		*再次检查是否应该添加线程
		*（因为自上次检查以来，已有的已死亡）或
		*自进入此方法后，池已关闭。所以我们
		*重新检查状态，如有必要，在以下情况下回滚排队
		*已停止，如果没有线程，则启动新线程。
		*
		* 3. 如果我们无法将任务排队，那么我们将尝试添加一个新任务
		*线。如果失败了，我们知道我们已经被关闭或饱和了
		*所以拒绝这个任务。
		*/
		拿到当前任务
        int c = ctl.get();
        判断当前任务数是否小于核心线程 如果当前线程小于核心线程数。 
        核心线程数目前是 ： 10
        if (workerCountOf(c) < corePoolSize) {
        	进入这个方法  这个addWorker 是一个关键方法； 
        	在这里 创建了Worker Worker 是 一条线程 + 任务；
        	这个就是worker的构造方法； 
        	/*  
			Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
       		 }
			*/
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
       当前当前线程数量大于10  那么就会进入这个方法； 然后会判断workQueue是否能储存任务；
       这个offer 就是判断是往队列里面添加任务； 这个workQueue  关键。
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            判断线程数量是否大于整个线程池承载数量。 目前我们设置的这个线程池承载数量是多少？
            是20个； 那就会根据你的拒绝策略  拒绝任务；
            if (! isRunning(recheck) && remove(command))
                reject(command);
            记住这个workerCountOf 这个最后也添加了Worker  但是添加的 是非核心线程池的任务； 
            这里 如果是我作为面试官。 我会问这个问题； 
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

以上是第一段源码；

不是特别的难。
我们开始根据图梳理一下逻辑
 1：我们开始 是往核心线程池里开始丢任务； 
 2：如果核心线程池满了任务； 开始往queue 队列里面丢任务；
 3：队列满了 开始往非核心线程池丢任务；
 到了21个任务 任务满了 抛出异常；

我们看一遍图。加深一下理解：
在这里插入图片描述

一张图我们就可解释清楚了任务进入线程池的一个加入顺序了；

这样我们开始来解释执行结果打印：

我们改一下代码；这里如果是 10 15 5 不好区分；我们改成 10 13 7

 ExecutorService HufExecutorService = new ThreadPoolExecutor(10, 13,
                0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(7));

一下是结果：
在这里插入图片描述

为什么 10~16 最后打印。现在应该明白了吧？
执行时：
在这里插入图片描述

这里我们就把线程池的执行流程弄清楚了以及任务加入队列这一部分的顺序弄清楚了；

ThreadPool 线程状态；

线程的生命周期的每一个转折点就是线程状态；

线程状态：
如果理解我第上一篇文章跟这一篇文章；线程池状态就很好理解；
线程池的线程生命周期的每一个点；

分别是

我们简单理解一下 Shutdown,Stop

我们使用线程池调用2个方法

HufExecutorService.shutdown(); //该线程池 转为shutdown状态
HufExecutorService.shutdownNow();// 该线程池转为 stop 状态

shutdown : 我们调用这个方法可以讲线程转变为 shutdown 状态；这时候在运行的线程还会继续运行；

stop : 我们调用 shutdownNow 方法线程池变成stop 那么线程不管它是否在运行都会立即停止；

这两个状态之后就会进入到 TidYing 状态就等待队列清空后调起： Terminated

Terminated 状态：线程池彻底终止；

线程池状态就完毕了；

线程本身的生命状态；
在这里插入图片描述

创建线程池的拒绝策略

一共有四种策略

AbortPolicy: 丢弃任务并抛出异常（RejectedExecutionException） *
DiscardPolicy：丢了任务不抛异常；
DiscardOldestPolicy：丢掉最早的任务然后执行该任务；
CallerRunsPolicy：把任务给到主线程执行（这样做有可能会急剧的拉低执行效率）
带星号的就是默认的。

ExecutorService HufExecutorService = new ThreadPoolExecutor(10, 13,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(7),
                new ThreadPoolExecutor.CallerRunsPolicy());