线程池解析

r囧r小猫 2024-02-28 08:00 95阅读 0赞

#### 文章目录 ####

*   *   *  1、平时使用哪些线程池，线程池默认的参数有哪些
         *  2、线程池的7个参数
         *  3、线程池状态
         *   *  ①、线程池各个状态切换图：
         *  4、线程池的使用
         *  5、线程池的好处
         *  6、线程池的整个流程
         *  7、Java的线程池说说
         *   *  ①、线程池概念
             *  ②、线程池的创建
             *  ③、任务执行
             *  ④、四种拒绝策略
             *  ⑤、形象描述线程池执行
             *  ⑥、按线程池内部机制，当提交新任务时，有哪些异常要考虑。
         *  8、线程池的工作队列
         *   *  ①、ArrayBlockingQueue
             *  ②、LinkedBlockingQueue
             *  ③、DelayWorkQueue
             *  ④、PriorityBlockingQueue
             *  ⑤、SynchronousQueue
         *  9、几种常用的线程池
         *   *  ①、newFixedThreadPool
             *   *  线程池特点：
                 *  工作机制：
                 *  抛出OOM异常面试
                 *  使用场景
             *  ②、newCachedThreadPool
             *   *  线程池特点：
                 *  工作机制
                 *  实例代码
                 *  使用场景
             *  ③、newSingleThreadExecutor
             *   *  线程池特点
                 *  工作机制
                 *  实例代码
             *  使用场景
             *  ④、newScheduledThreadPool
             *   *  线程池特点
                 *  工作机制
                 *  实例代码
     *  11、AQS

--------------------

#### 1、平时使用哪些线程池，线程池默认的参数有哪些 ####

在日常开发中，常常使用以下几种线程池：

1.  **FixedThreadPool（固定线程数线程池）**： 这种线程池的核心线程数是固定的，不会根据任务数量进行调整。适用于需要控制并发线程数的场景，如处理稳定且长期运行的任务。
2.  **CachedThreadPool（缓存线程池）**： 这种线程池的核心线程数为0，最大线程数是无限大的，线程数量会根据任务数量的变化动态调整。适用于处理大量短期的异步任务，自动调整线程数量可以避免线程过多造成资源浪费。
3.  **SingleThreadExecutor（单线程线程池）**： 这种线程池只有一个核心线程，适用于需要保证任务按照指定顺序顺序执行的场景，比如单个后台任务执行器。
4.  **ScheduledThreadPool（定时任务线程池）**： 这种线程池可以定期执行任务或者延时执行任务，适用于需要定时执行任务的场景，比如定时任务调度。

Java中的线程池在没有显式设置参数时，会使用默认的参数值。以下是Java 8中常见线程池（`ThreadPoolExecutor`）的默认参数：

1.  **FixedThreadPool（固定大小线程池）**：
    
     *  核心线程数：默认为固定大小，通常为CPU核心数。
     *  最大线程数：与核心线程数相同，因为FixedThreadPool是固定大小的线程池，不会创建额外的线程。
     *  线程空闲时间：默认为0秒，即线程在完成任务后立即回收。
     *  阻塞队列：使用的是无界的LinkedBlockingQueue，因为FixedThreadPool的线程数是固定的，不需要有界队列。
2.  **CachedThreadPool（缓存线程池）**：
    
     *  核心线程数：默认为0，因为CachedThreadPool是可缓存线程池，线程在空闲时会被回收。
     *  最大线程数：Integer.MAX\_VALUE，即没有限制。
     *  线程空闲时间：默认为60秒，即线程在空闲60秒后会被回收。
     *  阻塞队列：使用的是SynchronousQueue，它是一个没有 存储容量的队列，用于传递任务。
3.  **SingleThreadExecutor（单线程池）**：
    
     *  核心线程数：默认为1，SingleThreadPool只会创建一个线程。
     *  最大线程数：同样为1，SingleThreadPool只会创建一个线程。
     *  线程空闲时间：默认为0秒，线程在完成任务后立即回收。
     *  阻塞队列：使用的是LinkedBlockingQueue。
4.  **ScheduledThreadPool（定时任务线程池）**：
    
     *  核心线程数：默认为固定大小，通常为1。
     *  最大线程数：与核心线程数相同，因为ScheduledThreadPool是固定大小的线程池，不会创建额外的线程。
     *  线程空闲时间：默认为0秒，即线程在完成任务后立即回收。
     *  阻塞队列：使用的是DelayedWorkQueue，该队列根据任务的延迟时间来进行排序。

需要注意的是，这些默认参数可能因Java版本和具体的实现而有所不同。在使用线程池时，如果需要对线程池的参数进行更细致的控制，可以使用`ThreadPoolExecutor`类并显式设置参数。

#### 2、线程池的7个参数 ####

①、corePoolSize 线程池核心线程大小

②、maximumPoolSize 线程池最大线程数量

③、keepAliveTime 空闲线程存活时间

④、unit 空闲线程存活时间单位

⑤、workQueue 工作队列

⑥、threadFactory 线程工厂

**线程工厂：线程池创建线程时调用的工厂方法，通过此方法可以设置线程的优先级、线程命名规则以及线程类型（用户线程还是守护线程）等。**  
线程工厂的使用示例如下：

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");
        }
    }

⑦、handler 拒绝策略

#### 3、线程池状态 ####

##### ①、线程池各个状态切换图： #####

![image-20230905161248949][]

![image-20230928094145912][]

**RUNNING**

*  该状态的线程池会接收新任务，并处理阻塞队列中的任务;
 *  调用线程池的shutdown()方法，可以切换到SHUTDOWN状态;
 *  调用线程池的shutdownNow()方法，可以切换到STOP状态;

**SHUTDOWN**

*  该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
 *  队列为空，并且线程池中执行的任务也为空,进入TIDYING状态;

**STOP**

*  该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
 *  线程池中执行的任务为空,进入TIDYING状态;

**TIDYING**

*  该状态表明所有的任务已经运行终止，记录的任务数量为0。
 *  terminated()执行完毕，进入TERMINATED状态

**TERMINATED**

*  该状态表示线程池彻底终止

#### 4、线程池的使用 ####

在Java中，线程池的使用通常涉及以下步骤：

1.  **创建线程池：** 使用`ExecutorService`接口的工厂方法创建线程池。常见的创建线程池的方法包括：
    
     *  `Executors.newFixedThreadPool(int nThreads)`：创建固定大小的线程池，同时可以执行的线程数量为`nThreads`。
     *  `Executors.newCachedThreadPool()`：创建可缓存的线程池，线程池的大小可以根据需要自动调整。
2.  **提交任务：** 使用`ExecutorService`的`submit()`方法或`execute()`方法向线程池提交任务（`Runnable`或`Callable`类型的任务）。线程池会为任务分配线程来执行。
3.  **执行任务：** 线程池会自动调度线程来执行提交的任务。线程池会复用线程，当一个线程完成一个任务后，它会继续执行下一个任务，而不会销毁。
4.  **关闭线程池：** 当不再需要线程池时，应该调用`ExecutorService`的`shutdown()`或`shutdownNow()`方法来关闭线程池。`shutdown()`方法会允许线程池中已经提交的任务执行完毕，而`shutdownNow()`方法会立即停止线程池，并尝试中断正在执行的任务。

示例代码如下：

javaCopy codeimport java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ThreadPoolExample {
        public static void main(String[] args) {
            // 创建固定大小的线程池
            ExecutorService executorService = Executors.newFixedThreadPool(3);
    
            // 提交任务
            for (int i = 0; i < 10; i++) {
                final int taskId = i;
                executorService.submit(() -> {
                    System.out.println("Task " + taskId + " is being executed by thread " + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Task " + taskId + " completed.");
                });
            }
    
            // 关闭线程池
            executorService.shutdown();
        }
    }

在上述示例中，我们创建了一个固定大小为3的线程池，并向线程池提交了10个任务。线程池会自动分配3个线程来执行这些任务。任务会在不同的线程中并发执行，并且线程池会复用这些线程。最后，我们调用`shutdown()`方法关闭线程池。

#### 5、线程池的好处 ####

**降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

**提高响应速度**。当任务到达时，任务可以不需要等到线程创建就能立即执行。

**提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

#### 6、线程池的整个流程 ####

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

1.  如果当前运行的线程数小于核心线程数，那么就会新建一个线程来执行任务。
2.  如果当前运行的线程数等于或大于核心线程数，但是小于最大线程数，那么就把该任务放入到任务队列里等待执行。
3.  如果向任务队列投放任务失败（任务队列已经满了），但是当前运行的线程数是小于最大线程数的，就新建一个线程来执行任务。
4.  如果当前运行的线程数已经等同于最大线程数了，新建线程将会使当前运行的线程超出最大线程数，那么当前任务会被拒绝，饱和策略会调用`RejectedExecutionHandler.rejectedExecution()`方法。

#### 7、Java的线程池说说 ####

##### ①、线程池概念 #####

**线程池：** 简单理解，它就是一个管理线程的池子。

*  **它帮我们管理线程，避免增加创建线程和销毁线程的资源损耗**。因为线程其实也是一个对象，创建一个对象，需要经过类加载过程，销毁一个对象，需要走GC垃圾回收流程，都是需要资源开销的。
 *  **提高响应速度。** 如果任务到达了，相对于从线程池拿线程，重新去创建一条线程执行，速度肯定慢很多。
 *  **重复利用。** 线程用完，再放回池子，可以达到重复利用的效果，节省资源。

##### ②、线程池的创建 #####

线程池可以通过ThreadPoolExecutor来创建，我们来看一下它的构造函数：

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime,TimeUnit unit,   BlockingQueue<Runnable> workQueue,   ThreadFactory threadFactory,   RejectedExecutionHandler handler)

几个核心参数的作用：

*  **corePoolSize：** 线程池核心线程数最大值
 *  **maximumPoolSize：** 线程池最大线程数大小
 *  **keepAliveTime：** 线程池中非核心线程空闲的存活时间大小
 *  **unit：** 线程空闲存活时间单位
 *  **workQueue：** 存放任务的阻塞队列
 *  **threadFactory：** 用于设置创建线程的工厂，可以给创建的线程设置有意义的名字，可方便排查问题。
 *  **handler：** 线城池的饱和策略事件，主要有四种类型。

##### ③、任务执行 #####

**线程池执行流程，即对应execute()方法：**

![image-20230928093857736][]

*  提交一个任务，线程池里存活的核心线程数小于线程数corePoolSize时，线程池会创建一个核心线程去处理提交的任务。
 *  如果线程池核心线程数已满，即线程数已经等于corePoolSize，一个新提交的任务，会被放进任务队列workQueue排队等待执行。
 *  当线程池里面存活的线程数已经等于corePoolSize了,并且任务队列workQueue也满，判断线程数是否达到maximumPoolSize，即最大线程数是否已满，如果没到达，创建一个非核心线程执行提交的任务。
 *  如果当前的线程数达到了maximumPoolSize，还有新的任务过来的话，直接采用拒绝策略处理。

##### ④、四种拒绝策略 #####

*  AbortPolicy(直接丢弃任务，并抛出RejectedExecutionException异常)
 *  DiscardPolicy(直接丢弃任务，什么都不做)
 *  DiscardOldestPolicy（抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列）
 *  CallerRunsPolicy（用于被拒绝任务的处理程序，它直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务)

##### ⑤、形象描述线程池执行 #####

*  核心线程比作公司正式员工
 *  非核心线程比作外包员工
 *  阻塞队列比作需求池
 *  提交任务比作提需求
 *  当产品提个需求，正式员工（核心线程）先接需求（执行任务）
 *  如果正式员工都有需求在做，即核心线程数已满），产品就把需求先放需求池（阻塞队列）。
 *  如果需求池(阻塞队列)也满了，但是这时候产品继续提需求,怎么办呢？那就请外包（非核心线程）来做。
 *  如果所有员工（最大线程数也满了）都有需求在做了，那就执行拒绝策略。
 *  如果外包员工把需求做完了，它经过一段（keepAliveTime）空闲时间，就离开公司了。

##### ⑥、按线程池内部机制，当提交新任务时，有哪些异常要考虑。 #####

![image-20230806103128438][]

#### 8、线程池的工作队列 ####

**线程池都有哪几种工作队列？**

*  ArrayBlockingQueue
 *  LinkedBlockingQueue
 *  DelayQueue
 *  PriorityBlockingQueue
 *  SynchronousQueue

##### ①、ArrayBlockingQueue #####

ArrayBlockingQueue（有界队列）是一个用数组实现的有界阻塞队列，按FIFO排序量。

##### ②、LinkedBlockingQueue #####

LinkedBlockingQueue（可设置容量队列）基于链表结构的阻塞队列，按FIFO排序任务，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX\_VALUE，吞吐量通常要高于ArrayBlockingQuene；newFixedThreadPool线程池使用了这个队列

##### ③、DelayWorkQueue #####

DelayWorkQueue（延迟队列）是一个任务定时周期的延迟执行的队列。根据指定的执行时间从小到大排序，否则根据插入到队列的先后排序。newScheduledThreadPool线程池使用了这个队列。

##### ④、PriorityBlockingQueue #####

PriorityBlockingQueue（优先级队列）是具有优先级的无界阻塞队列；

##### ⑤、SynchronousQueue #####

SynchronousQueue（同步队列）一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene，newCachedThreadPool线程池使用了这个队列。

#### 9、几种常用的线程池 ####

*  newFixedThreadPool (固定数目线程的线程池)
 *  newCachedThreadPool(可缓存线程的线程池)
 *  newSingleThreadExecutor(单线程的线程池)
 *  newScheduledThreadPool(定时及周期执行的线程池)

##### ①、newFixedThreadPool #####

/**
         * 创建一个可重用固定数量线程的线程池
         */
        public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        
            return new ThreadPoolExecutor(nThreads, nThreads, 
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>(),
                                          threadFactory);
        }

###### 线程池特点： ######

*  核心线程数和最大线程数大小一样
 *  没有所谓的非空闲时间，即keepAliveTime为0
 *  阻塞队列为无界队列LinkedBlockingQueue

###### 工作机制： ######

![image-20230928094215711][]

*  提交任务
 *  如果线程数少于核心线程，创建核心线程执行任务
 *  如果线程数等于核心线程，把任务添加到LinkedBlockingQueue阻塞队列
 *  如果线程执行完任务，去阻塞队列取任务，继续执行。

###### 抛出OOM异常面试 ######

IDE指定JVM参数：-Xmx8m -Xms8m :

![image-20230928094238371][]

run以上代码，会抛出OOM：

![image-20230928094256949][]

###### 使用场景 ######

FixedThreadPool 适用于处理CPU密集型的任务，确保CPU在长期被工作线程使用的情况下，尽可能的少的分配线程，即适用执行长期的任务。

##### ②、newCachedThreadPool #####

/**
         * 创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它。
         */
        public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>(),
                                          threadFactory);
        }

###### 线程池特点： ######

*  核心线程数为0
 *  最大线程数为Integer.MAX\_VALUE
 *  阻塞队列是SynchronousQueue
 *  非核心线程空闲存活时间为60秒

当提交任务的速度大于处理任务的速度时，每次提交一个任务，就必然会创建一个线程。极端情况下会创建过多的线程，耗尽 CPU 和内存资源。由于空闲 60 秒的线程会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。

###### 工作机制 ######

![image-20230928094318436][]

*  提交任务
 *  因为没有核心线程，所以任务直接加到SynchronousQueue队列。
 *  判断是否有空闲线程，如果有，就去取出任务执行。
 *  如果没有空闲线程，就新建一个线程执行。
 *  执行完任务的线程，还可以存活60秒，如果在这期间，接到任务，可以继续活下去；否则，被销毁。

###### 实例代码 ######

![image-20230928094344366][]

###### 使用场景 ######

用于并发执行大量短期的小任务。

##### ③、newSingleThreadExecutor #####

/**
         *返回只有一个线程的线程池
         */
        public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>(),
                                        threadFactory));
        }

###### 线程池特点 ######

*  核心线程数为1
 *  最大线程数也为1
 *  阻塞队列是LinkedBlockingQueue
 *  keepAliveTime为0

###### 工作机制 ######

![image-20230928094406442][]

*  提交任务
 *  线程池是否有一条线程在，如果没有，新建线程执行任务
 *  如果有，讲任务加到阻塞队列
 *  当前的唯一线程，从队列取任务，执行完一个，再继续取，一个人（一条线程）夜以继日地干活。

###### 实例代码 ######

![image-20230928094426680][]

##### 使用场景 #####

适用于串行执行任务的场景，一个任务一个任务地执行。

##### ④、newScheduledThreadPool #####

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

###### 线程池特点 ######

*  最大线程数为Integer.MAX\_VALUE
 *  阻塞队列是DelayedWorkQueue
 *  keepAliveTime为0
 *  scheduleAtFixedRate() ：按某种速率周期执行
 *  scheduleWithFixedDelay()：在某个延迟后执行

###### 工作机制 ######

*  添加一个任务
 *  线程池中的线程从 DelayQueue 中取任务
 *  线程从 DelayQueue 中获取 time 大于等于当前时间的task
 *  执行完后修改这个 task 的 time 为下次被执行的时间
 *  这个 task 放回DelayQueue队列中

###### 实例代码 ######

![image-20230928094439293][]

/**    创建一个给定初始延迟的间隔性的任务，之后的每次任务执行时间为 初始延迟 + N * delay(间隔)    */    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);                                           scheduledExecutorService.scheduleAtFixedRate(()->{                                                           System.out.println("current Time" + System.currentTimeMillis());                                             System.out.println(Thread.currentThread().getName()+"正在执行");        
        }, 1, 3, TimeUnit.SECONDS);;

### 11、AQS ###

[image-20230905161248949]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/d070f9bf9e124d66aec578889b802d3e.png
[image-20230928094145912]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/6d0282f0d3044ab79d4ab31bf0683558.png
[image-20230928093857736]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/78cabc2b1b934c8b85244dde73438b67.png
[image-20230806103128438]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/e58cd4d29fe4492a97ac7a12ccea2ee2.png
[image-20230928094215711]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/9a8e118a7e894db49ae637f4cb8f0794.png
[image-20230928094238371]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/1d9d4cc26db84374908ddbace59b3599.png
[image-20230928094256949]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/c84bcaf46b944d62a3418dab430069e7.png
[image-20230928094318436]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/16ee3d28cead47389c8ae0dbf2e4f8f4.png
[image-20230928094344366]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/84151aa15d794d9fbee40de8cbf654a6.png
[image-20230928094406442]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/214a785596c34cbaa652b80078998bd0.png
[image-20230928094426680]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/d6fb365639e94b1985ffbe5242508803.png
[image-20230928094439293]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/28/6bc63797f0cc498289641476dca93fcf.png