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

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

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

线程池的任务执行流程；

我先上一段代码：

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

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

放出全部代码：

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 那么线程 不管它是否在运行 都会立即停止；

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

线程池状态就完毕了；

线程本身的生命状态；

创建线程池的拒绝策略

一共有四种策略

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

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

就是这样 把拒绝策略加入到了该线程池当中；

总结：

• 线程池的执行流程
• 线程池解释了线程中源码的过程；当中addWorker 没讲 如果需要讲解；（点赞超过150 就讲解这部分东西，或者自己去研究。建议自己研究。里面东西写得有些许羞涩 但是绝对不难看懂；只要跟着源码走，而且能知道为什么运行十万次 只需要100毫秒的究极原因）
• 四种拒绝策略；

see you