Java学习11（线程池）

不念不忘少年蓝@ 2024-03-23 16:29 70阅读 0赞

***1、线程池介绍？***

**线程池就是管理一系列线程的资源池**，其提供了一种限制和管理线程资源的方式。每个线程池还维护一些基本统计信息，例如已完成任务的数量。

《Java 并发编程的艺术》书中的部分内容来总结一下使用线程池的好处：

*  降低资源消耗。通过**重复利用已创建的线程降低线程创建和销毁造成的消耗**。
 *  提高响应速度。当**任务到达时，任务可以不需要等到线程创建就能立即执行**。
 *  提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

**线程池一般用于执行多个不相关联的耗时任务，没有多线程的情况下，任务顺序执行，使用了线程池的话可让多个不相关联的任务同时执行。**

***2、Executor 框架介绍***

`Executor` 框架是 Java5 之后引进的，在 Java 5 之后，通过 `Executor` 来启动线程比使用 `Thread` 的 `start` 方法更好，**除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题**。

this 逃逸是指在构造函数返回之前其他线程就持有该对象的引用，调用尚未构造完全的对象的方法可能引发令人疑惑的错误。

`Executor` 框架不仅包括了线程池的管理，还提供了线程工厂、队列以及拒绝策略等，`Executor` 框架让并发编程变得更加简单。

`Executor` 框架结构主要由三大部分组成：

**1、任务(Runnable /Callable)**

执行任务需要实现的 `Runnable` 接口 或 `Callable`接口。`Runnable` 接口或 `Callable` 接口 实现类都可以被 `ThreadPoolExecutor` 或 `ScheduledThreadPoolExecutor` 执行。

**2、任务的执行(Executor)**

包括任务执行机制的核心接口 `Executor` ，以及继承自 `Executor` 接口的 `ExecutorService` 接口。`ThreadPoolExecutor` 和 `ScheduledThreadPoolExecutor` 这两个关键类实现了 `ExecutorService` 接口。  
![在这里插入图片描述][3858cc60f6c04652a8974cb782baab36.png]

这里提了很多底层的类关系，但是，实际上我们需要更多关注的是 `ThreadPoolExecutor` 这个类，这个类在我们实际使用线程池的过程中，使用频率还是非常高的。

**注意：** 通过查看 `ScheduledThreadPoolExecutor` 源代码我们发现 `ScheduledThreadPoolExecutor` 实际上是继承了 `ThreadPoolExecutor` 并实现了 `ScheduledExecutorService` ，而 `ScheduledExecutorService` 又实现了 `ExecutorService`，正如我们上面给出的类关系图显示的一样。

`ThreadPoolExecutor` 类述:

//AbstractExecutorService实现了ExecutorService接口
    public class ThreadPoolExecutor extends AbstractExecutorService

`ScheduledThreadPoolExecutor` 类描述:

//ScheduledExecutorService继承ExecutorService接口
    public class ScheduledThreadPoolExecutor
            extends ThreadPoolExecutor
            implements ScheduledExecutorService

**3、异步计算的结果(Future)**

`Future` 接口以及 `Future` 接口的实现类 `FutureTask` 类都可以代表异步计算的结果。当我们把 `Runnable`接口 或 `Callable` 接口 的实现类提交给 `ThreadPoolExecutor` 或 `ScheduledThreadPoolExecutor` 执行。（调用 `submit()` 方法时会返回一个 `FutureTask` 对象）

`Executor` 框架的使用示意图 ：  
![在这里插入图片描述][96ab6e0c07ef479883627c1a6dd243b7.png]

1.  主线程首先要创建实现 `Runnable` 或者 `Callable` 接口的任务对象。
2.  把创建完成的实现 `Runnable/Callable`接口的 **对象**直接交给 `ExecutorService` 执行: `ExecutorService.execute（Runnable command））`或者也可以把 `Runnable` 对象或`Callable` 对象提交给 `ExecutorService` 执行（`ExecutorService.submit（Runnable task）`或 `ExecutorService.submit（Callable <T> task））`。
3.  如果执行 `ExecutorService.submit（…）`，`ExecutorService` 将返回一个实现`Future`接口的**对象**（我们刚刚也提到过了执行 `execute()`方法和 `submit()`方法的区别，`submit()`会返回一个 `FutureTask` 对象）。由于 `FutureTask` 实现了 `Runnable`，我们也可以创建 `FutureTask`，然后直接交给 `ExecutorService` 执行。
4.  最后，主线程可以执行 `FutureTask.get()`方法来**等待任务执行完成**。主线程也可以执行 `FutureTask.cancel（boolean mayInterruptIfRunning）`来**取消此任务的执行**。

***3、ThreadPoolExecutor类介绍？***

线程池实现类 `ThreadPoolExecutor` 是 `Executor` 框架最核心的类。

**构造方法介绍**

`ThreadPoolExecutor` 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么）。

/**
         * 用给定的初始参数创建一个新的ThreadPoolExecutor。
         */
        public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
                                  int maximumPoolSize,//线程池的最大线程数
                                  long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
                                  TimeUnit unit,//时间单位
                                  BlockingQueue<Runnable> 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.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.workQueue = workQueue;
            this.keepAliveTime = unit.toNanos(keepAliveTime);
            this.threadFactory = threadFactory;
            this.handler = handler;
        }

下面这些对创建非常重要。`ThreadPoolExecutor` 3 个最重要的参数：

*  `corePoolSize` : 任务队列未达到队列容量时，最大可以同时运行的线程数量。
 *  `maximumPoolSize` : 任务队列中存放的任务**达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数**。
 *  `workQueue`: 新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

ThreadPoolExecutor其他常见参数 :

*  `keepAliveTime`:线程池中的线程数量大于 `corePoolSize` 的时候，**如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 `keepAliveTime`才会被回收销毁**。
 *  `unit` : `keepAliveTime` 参数的时间单位。
 *  `threadFactory` :`executor` 创建新线程的时候会用到。
 *  `handler` :饱和策略。

下面这张图可以加深你对线程池中各个参数的相互关系的理解  
![在这里插入图片描述][c6c75b812f91445d91d0dc4d88bb114c.png]

`ThreadPoolExecutor` **饱和策略定义:**

**如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时，`ThreadPoolTaskExecutor` 定义一些策略:**

*  `ThreadPoolExecutor.AbortPolicy` ：抛出 `RejectedExecutionException`来拒绝新任务的处理。
 *  `ThreadPoolExecutor.CallerRunsPolicy` ：调用执行自己的线程运行任务，也就是直接在调用`execute`方法的线程中运行(`run`)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。
 *  `ThreadPoolExecutor.DiscardPolicy` ：不处理新任务，直接丢弃掉。
 *  `ThreadPoolExecutor.DiscardOldestPolicy` ： 此策略将丢弃最早的未处理的任务请求。

举个例子：

Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候，当我们不指定 `RejectedExecutionHandler` 饱和策略的话来配置线程池的时候默认使用的是 `ThreadPoolExecutor.AbortPolicy`。

在默认情况下，`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用 `ThreadPoolExecutor.CallerRunsPolicy`。当最大池被填满时，**此策略为我们提供可伸缩队列**。

***4、线程池创建的两种方式？***

**方式一**：通过`ThreadPoolExecutor`构造函数来创建（推荐）。

![在这里插入图片描述][1074db46919144e394f53184b9d5f9b4.png]  
**方式二：** 通过 Executor 框架的工具类 Executors 来创建。

我们可以创建多种类型的 `ThreadPoolExecutor`：

*  `FixedThreadPool` ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
 *  `SingleThreadExecutor`： 该方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
 *  `CachedThreadPool`： 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。
 *  `ScheduledThreadPool` ：该返回一个用来在给定的延迟后运行任务或者定期执行任务的线程池。

《阿里巴巴 Java 开发手册》强制线程池**不允许使用 Executors 去创建**，而是**通过 ThreadPoolExecutor 构造函数的方式**，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

`Executors` 返回线程池对象的弊端如下：

*  `FixedThreadPool` 和 `SingleThreadExecutor` ： 使用的是无界的 `LinkedBlockingQueue`，任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求，从而导致 OOM。
 *  `CachedThreadPool` ：使用的是同步队列 `SynchronousQueue`, 允许创建的线程数量为 `Integer.MAX_VALUE` ，可能会创建大量线程，从而导致 OOM。
 *  `ScheduledThreadPool` 和 `SingleThreadScheduledExecutor` : 使用的无界的延迟阻塞队列`DelayedWorkQueue`，任务队列最大长度为 `Integer.MAX_VALUE`,可能堆积大量的请求，从而导致 OOM。

// 无界队列 LinkedBlockingQueue
    public static ExecutorService newFixedThreadPool(int nThreads) {
        
    
        return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
    
    }
    
    // 无界队列 LinkedBlockingQueue
    public static ExecutorService newSingleThreadExecutor() {
        
    
        return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
    
    }
    
    // 同步队列 SynchronousQueue，没有容量，最大线程数是 Integer.MAX_VALUE`
    public static ExecutorService newCachedThreadPool() {
        
    
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
    
    }
    
    // DelayedWorkQueue（延迟阻塞队列）
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

***5、线程池常用的阻塞队列总结？***

新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

不同的线程池会选用不同的阻塞队列，我们可以结合内置线程池来分析。

*  容量为 `Integer.MAX_VALUE` 的 `LinkedBlockingQueue`（无界队列）：`FixedThreadPool` 和 `SingleThreadExector` 。由于**队列永远不会被放满**，因此`FixedThreadPool`最多只能创建核心线程数的线程。
 *  `SynchronousQueue`（同步队列） ：`CachedThreadPool` 。`SynchronousQueue` **没有容量，不存储元素**，目的**是保证对于提交的任务，如果有空闲线程，则使用空闲线程来处理；否则新建一个线程来处理任务**。也就是说，`CachedThreadPool` 的最大线程数是 `Integer.MAX_VALUE` ，可以理解为**线程数是可以无限扩展的，可能会创建大量线程，从而导致 OOM**。
 *  `DelayedWorkQueue`（延迟阻塞队列）：`ScheduledThreadPool` 和 `SingleThreadScheduledExecutor` 。`DelayedWorkQueue` 的内部元素**并不是按照放入的时间排序，而是会按照延迟的时间长短对任务进行排序，内部采用的是“堆”的数据结构**，可以保证每次出队的任务都是当前队列中执行时间最靠前的。`DelayedWorkQueue` 添加元素满了之后**会自动扩容原来容量的 1/2，即永远不会阻塞，最大扩容可达 Integer.MAX\_VALUE，所以最多只能创建核心线程数的线程。**

***6、线程池原理分析？***

`ThreadPoolExecutor` 示例代码：

首先创建一个 `Runnable` 接口的实现类（当然也可以是 `Callable` 接口，我们上面也说了两者的区别。）

`MyRunnable.java`

import java.util.Date;
    
    /**
     * 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
     * @author shuang.kou
     */
    public class MyRunnable implements Runnable {
        
    
        private String command;
    
        public MyRunnable(String s) {
        
            this.command = s;
        }
    
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
            processCommand();
            System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
        }
    
        private void processCommand() {
        
            try {
        
                Thread.sleep(5000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    
        @Override
        public String toString() {
        
            return this.command;
        }
    }

编写测试程序，我们这里以阿里巴巴推荐的使用 `ThreadPoolExecutor` 构造函数自定义参数的方式来创建线程池。

`ThreadPoolExecutorDemo` `.java`

import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadPoolExecutorDemo {
        
    
        private static final int CORE_POOL_SIZE = 5;
        private static final int MAX_POOL_SIZE = 10;
        private static final int QUEUE_CAPACITY = 100;
        private static final Long KEEP_ALIVE_TIME = 1L;
        public static void main(String[] args) {
        
    
            //使用阿里巴巴推荐的创建线程池的方式
            //通过ThreadPoolExecutor构造函数自定义参数创建
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                    CORE_POOL_SIZE,
                    MAX_POOL_SIZE,
                    KEEP_ALIVE_TIME,
                    TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                    new ThreadPoolExecutor.CallerRunsPolicy());
    
            for (int i = 0; i < 10; i++) {
        
                //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
                Runnable worker = new MyRunnable("" + i);
                //执行Runnable
                executor.execute(worker);
            }
            //终止线程池
            executor.shutdown();
            while (!executor.isTerminated()) {
        
            }
            System.out.println("Finished all threads");
        }
    }

可以看到我们上面的代码指定了：

*  corePoolSize: 核心线程数为 5。
 *  maximumPoolSize ：最大线程数 10。
 *  keepAliveTime : 等待时间为 1L。
 *  unit: 等待时间的单位为 TimeUnit.SECONDS。
 *  workQueue：任务队列为 ArrayBlockingQueue，并且容量为 100;
 *  handler:饱和策略为 CallerRunsPolicy。

输出结构 ：

pool-1-thread-3 Start. Time = Sun Apr 12 11:14:37 CST 2020
    pool-1-thread-5 Start. Time = Sun Apr 12 11:14:37 CST 2020
    pool-1-thread-2 Start. Time = Sun Apr 12 11:14:37 CST 2020
    pool-1-thread-1 Start. Time = Sun Apr 12 11:14:37 CST 2020
    pool-1-thread-4 Start. Time = Sun Apr 12 11:14:37 CST 2020
    pool-1-thread-3 End. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-4 End. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-1 End. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-5 End. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-1 Start. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-2 End. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-5 Start. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-4 Start. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-3 Start. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-2 Start. Time = Sun Apr 12 11:14:42 CST 2020
    pool-1-thread-1 End. Time = Sun Apr 12 11:14:47 CST 2020
    pool-1-thread-4 End. Time = Sun Apr 12 11:14:47 CST 2020
    pool-1-thread-5 End. Time = Sun Apr 12 11:14:47 CST 2020
    pool-1-thread-3 End. Time = Sun Apr 12 11:14:47 CST 2020
    pool-1-thread-2 End. Time = Sun Apr 12 11:14:47 CST 2020

**线程池原理分析：**

我们通过前面的代码输出结果可以看出：线程池首先会先执行 5 个任务，然后这些任务有任务被执行完的话，就会去拿新的任务执行。

为了搞懂线程池的原理，我们需要首先分析一下 `execute`方法。 在示例代码中，我们使用 `executor.execute(worker)`来提交一个任务到线程池中去。

这个方法非常重要，下面我们来看看它的源码：

// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
       private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    
        private static int workerCountOf(int c) {
        
            return c & CAPACITY;
        }
        //任务队列
        private final BlockingQueue<Runnable> workQueue;
    
        public void execute(Runnable command) {
        
            // 如果任务为null，则抛出异常。
            if (command == null)
                throw new NullPointerException();
            // ctl 中保存的线程池当前的一些状态信息
            int c = ctl.get();
    
            //  下面会涉及到 3 步 操作
            // 1.首先判断当前线程池中执行的任务数量是否小于 corePoolSize
            // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
            if (workerCountOf(c) < corePoolSize) {
        
                if (addWorker(command, true))
                    return;
                c = ctl.get();
            }
            // 2.如果当前执行的任务数量大于等于 corePoolSize 的时候就会走到这里，表明创建新的线程失败。
            // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态并且队列可以加入任务，该任务才会被加入进去
            if (isRunning(c) && workQueue.offer(command)) {
        
                int recheck = ctl.get();
                // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
                if (!isRunning(recheck) && remove(command))
                    reject(command);
                    // 如果当前工作线程数量为0，新创建一个线程并执行。
                else if (workerCountOf(recheck) == 0)
                    addWorker(null, false);
            }
            //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
            // 传入 false 代表增加线程时判断当前线程数是否少于 maxPoolSize
            //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
            else if (!addWorker(command, false))
                reject(command);
        }

这里简单分析一下整个流程（对整个逻辑进行了简化，方便理解）：

1、如果当前运行的线程数小于核心线程数，那么就会新建一个线程来执行任务。

2、如果当前运行的线程数等于或大于核心线程数，但是小于最大线程数，那么就把该任务放入到任务队列里等待执行。

3、如果向任务队列投放任务失败（任务队列已经满了），但是当前运行的线程数是小于最大线程数的，就新建一个线程来执行任务。

4、如果当前运行的线程数已经等同于最大线程数了，新建线程将会使当前运行的线程超出最大线程数，那么当前任务会被拒绝，饱和策略会调用`RejectedExecutionHandler.rejectedExecution()`方法。  
![在这里插入图片描述][b300cfe1215b41d6ab3b0ba44d380c25.png]

在 `execute` 方法中，多次调用 `addWorker` 方法。`addWorker` 这个方法**主要用来创建新的工作线程，如果返回 true 说明创建和启动工作线程成功，否则的话返回的就是 false。**

// 全局锁，并发操作必备
        private final ReentrantLock mainLock = new ReentrantLock();
        // 跟踪线程池的最大大小，只有在持有全局锁mainLock的前提下才能访问此集合
        private int largestPoolSize;
        // 工作线程集合，存放线程池中所有的（活跃的）工作线程，只有在持有全局锁mainLock的前提下才能访问此集合
        private final HashSet<Worker> workers = new HashSet<>();
        //获取线程池状态
        private static int runStateOf(int c)     {
         return c & ~CAPACITY; }
        //判断线程池的状态是否为 Running
        private static boolean isRunning(int c) {
        
            return c < SHUTDOWN;
        }
    
    
        /**
         * 添加新的工作线程到线程池
         * @param firstTask 要执行
         * @param core参数为true的话表示使用线程池的基本大小，为false使用线程池最大大小
         * @return 添加成功就返回true否则返回false
         */
       private boolean addWorker(Runnable firstTask, boolean core) {
        
            retry:
            for (;;) {
        
                //这两句用来获取线程池的状态
                int c = ctl.get();
                int rs = runStateOf(c);
    
                // Check if queue empty only if necessary.
                if (rs >= SHUTDOWN &&
                    ! (rs == SHUTDOWN &&
                       firstTask == null &&
                       ! workQueue.isEmpty()))
                    return false;
    
                for (;;) {
        
                   //获取线程池中工作的线程的数量
                    int wc = workerCountOf(c);
                    // core参数为false的话表明队列也满了，线程池大小变为 maximumPoolSize
                    if (wc >= CAPACITY ||
                        wc >= (core ? corePoolSize : maximumPoolSize))
                        return false;
                   //原子操作将workcount的数量加1
                    if (compareAndIncrementWorkerCount(c))
                        break retry;
                    // 如果线程的状态改变了就再次执行上述操作
                    c = ctl.get();
                    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 {
        
    
                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());
                       //rs < SHUTDOWN 如果线程池状态依然为RUNNING,并且线程的状态是存活的话，就会将工作线程添加到工作线程集合中
                      //(rs=SHUTDOWN && firstTask == null)如果线程池状态小于STOP，也就是RUNNING或者SHUTDOWN状态下，同时传入的任务实例firstTask为null，则需要添加到工作线程集合和启动新的Worker
                       // firstTask == null证明只新建线程而不执行任务
                        if (rs < SHUTDOWN ||
                            (rs == SHUTDOWN && firstTask == null)) {
        
                            if (t.isAlive()) // precheck that t is startable
                                throw new IllegalThreadStateException();
                            workers.add(w);
                           //更新当前工作线程的最大容量
                            int s = workers.size();
                            if (s > largestPoolSize)
                                largestPoolSize = s;
                          // 工作线程是否启动成功
                            workerAdded = true;
                        }
                    } finally {
        
                        // 释放锁
                        mainLock.unlock();
                    }
                     如果成功添加工作线程，则调用Worker内部的线程实例t的Thread#start()方法启动真实的线程实例
                    if (workerAdded) {
        
                        t.start();
                      /// 标记线程启动成功
                        workerStarted = true;
                    }
                }
            } finally {
        
               // 线程启动失败，需要从工作线程中移除对应的Worker
                if (! workerStarted)
                    addWorkerFailed(w);
            }
            return workerStarted;
        }

通俗而言：

我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务中如果有任务被执行完了，线程池就会去拿新的任务执行。

***7、Runnable 和 Callable对比？***

`Runnable`自 Java 1.0 以来一直存在，但`Callable`仅在 Java 1.5 中引入,目的就是为了来处理`Runnable`不支持的用例。`Runnable` 接口不会返回结果或抛出检查异常，但是 `Callable` 接口可以。所以，如果任务不需要返回结果或抛出异常推荐使用 `Runnable` 接口，这样代码看起来会更加简洁。

工具类 `Executors` 可以实现将 `Runnable` 对象转换成 `Callable` 对象。（`Executors.callable(Runnable task)` 或 `Executors.callable(Runnable task, Object result)）`。

**Runnable.java**

@FunctionalInterface
    public interface Runnable {
        
       /**
        * 被线程执行，没有返回值也无法抛出异常
        */
        public abstract void run();
    }

**Callable.java**

@FunctionalInterface
    public interface Callable<V> {
        
        /**
         * 计算结果，或在无法这样做时抛出异常。
         * @return 计算得出的结果
         * @throws 如果无法计算结果，则抛出异常
         */
        V call() throws Exception;
    }

***8、execute() 和 submit() 比较？***

*  `execute()`方法用于**提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否**；
 *  `submit()`方法用于**提交需要返回值的任务**。线程池**会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功**，并且可以通过 `Future` 的 `get()`方法来获取返回值，`get()`方法**会阻塞当前线程直到任务完成**，而使用 \*\*get（long timeout，TimeUnit unit）\*\*方法的话，如果在 `timeout` 时间内任务还没有执行完，就会抛出 `java.util.concurrent.TimeoutException`。

***9、shutdown()和shutdownNow()的对比？***

*  **shutdown（）** :关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。
 *  **shutdownNow（）** :关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。

10、***isTerminated() VS isShutdown()***

*  `isShutDown` 当调用 shutdown() 方法后返回为 true。
 *  `isTerminated` 当调用 shutdown() 方法后，并且所有提交的任务完成后返回为 true。

[3858cc60f6c04652a8974cb782baab36.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/0ee105ddbd9e4947ae5e3ed8a0c13649.png
[96ab6e0c07ef479883627c1a6dd243b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/7edcd7a83c184903b86eca464f8bb53f.png
[c6c75b812f91445d91d0dc4d88bb114c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/bb693e78ac91435bb181ed4e66fe6087.png
[1074db46919144e394f53184b9d5f9b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ac6a9b8678054ac0a1f81ffdea40969e.png
[b300cfe1215b41d6ab3b0ba44d380c25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/b028d81da2014ee2837b3ca9511ae222.png