线程池解析

Qgchun.

已于 2023-09-28 09:54:36 修改

阅读量301

点赞数

文章标签： java

于 2023-09-28 09:53:56 首次发布

QGC

本文链接：https://blog.csdn.net/weixin_54040016/article/details/133376726

版权

文章目录

- 11、AQS

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

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

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

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

FixedThreadPool（固定大小线程池）：
- 核心线程数：默认为固定大小，通常为CPU核心数。
- 最大线程数：与核心线程数相同，因为FixedThreadPool是固定大小的线程池，不会创建额外的线程。
- 线程空闲时间：默认为0秒，即线程在完成任务后立即回收。
- 阻塞队列：使用的是无界的LinkedBlockingQueue，因为FixedThreadPool的线程数是固定的，不需要有界队列。
CachedThreadPool（缓存线程池）：
- 核心线程数：默认为0，因为CachedThreadPool是可缓存线程池，线程在空闲时会被回收。
- 最大线程数：Integer.MAX_VALUE，即没有限制。
- 线程空闲时间：默认为60秒，即线程在空闲60秒后会被回收。
- 阻塞队列：使用的是SynchronousQueue，它是一个没有存储容量的队列，用于传递任务。
SingleThreadExecutor（单线程池）：
- 核心线程数：默认为1，SingleThreadPool只会创建一个线程。
- 最大线程数：同样为1，SingleThreadPool只会创建一个线程。
- 线程空闲时间：默认为0秒，线程在完成任务后立即回收。
- 阻塞队列：使用的是LinkedBlockingQueue。
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、线程池状态

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

RUNNING

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

SHUTDOWN

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

STOP

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

TIDYING

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

TERMINATED

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

4、线程池的使用

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

创建线程池： 使用ExecutorService接口的工厂方法创建线程池。常见的创建线程池的方法包括：
- Executors.newFixedThreadPool(int nThreads)：创建固定大小的线程池，同时可以执行的线程数量为nThreads。
- Executors.newCachedThreadPool()：创建可缓存的线程池，线程池的大小可以根据需要自动调整。
提交任务： 使用ExecutorService的submit()方法或execute()方法向线程池提交任务（Runnable或Callable类型的任务）。线程池会为任务分配线程来执行。
执行任务： 线程池会自动调度线程来执行提交的任务。线程池会复用线程，当一个线程完成一个任务后，它会继续执行下一个任务，而不会销毁。
关闭线程池： 当不再需要线程池时，应该调用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、线程池的整个流程

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

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

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

④、四种拒绝策略

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

⑤、形象描述线程池执行

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

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

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

工作机制：

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

抛出OOM异常面试

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

run以上代码，会抛出OOM：

使用场景

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 不会占用任何资源。

工作机制

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

实例代码

使用场景

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

③、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

工作机制

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

实例代码

使用场景

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

④、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队列中

实例代码

    /**    创建一个给定初始延迟的间隔性的任务，之后的每次任务执行时间为 初始延迟 + 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);;