JUC系列(九)| ThreadPool 线程池

·  阅读 522
JUC系列(九)| ThreadPool 线程池

这是我参与8月更文挑战的第24天,活动详情查看:8月更文挑战

多线程一直Java开发中的难点,也是面试中的常客,趁着还有时间,打算巩固一下JUC方面知识,我想机会随处可见,但始终都是留给有准备的人的,希望我们都能加油!!!

沉下去,再浮上来,我想我们会变的不一样的。

🍟线程池介绍

1)什么是线程池?

线程池(英语:thread pool):一种线程使用模式。由系统维护的容纳线程的容器,由CLR控制的所有AppDomain共享。线程池可用于执行任务、发送工作项、处理异步 I/O、代表其他线程等待以及处理计时器。

2)为什么要使用线程池?

痛点:

  1. 不使用线程池的话,每次请求都会创建新的线程,然后销毁,资源消耗大,复用率低。
  2. 在Java中,线程的线程栈所占用的内存在Java堆外,不受Java程序控制,只受系统资源限制(如若系统给资源不足,可能创建失败),默认一个线程的线程栈大小是1M。如果每个请求都新建线程,1024个线程就会占用1个G内存,系统很容易崩溃。
  3. 如若系统庞大,仍每次都在代码中新建线程,不好管理,难以找到错误,也不好监控、调优。
  4. 线程过多会带来调度开销, 进而影响缓存局部性和整体性能。

原因:

线程池维护着多个线程,等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用,还能防止过分调度。

线程池的优势

线程池做的工作只要是控制运行的线程数量,处理过程中将任务放入队列,然后在线程创建后启动这些任务,如果线程数量超过了最大数量, 超出数量的线程排队等候,等其他线程执行完毕,再从队列中取出任务来执行。

另外在我们常常看的阿里巴巴Java开发手册也有提到:

【强制】线程资源必须通过线程池提供,不允许在应用中自行显式创建线程。

说明:使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销,解决资源不足的问题。如果不使用线程池,有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

3)特点

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

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

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

4)架构

Java 中的线程池是通过 Executor 框架实现的,该框架中用到了 Executor, ExecutorService,ThreadPoolExecutor, 这几个类

另外还有Executors这个方便封装的工具类。但是不建议使用😂

image-20210822143232276.png

5)线程池参数说明

ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
复制代码
  1. corePoolSize 线程池的核心线程数
    • 当提交一个任务时,如果当前核心线程池的线程个数没有达到 corePoolSize,则会创建新的线程来执行所提交的任务,即使当前核心线程池有空闲的线程。如果当前核心线程池的线程个数已经达到了 corePoolSize,则不再重新创建线程。
  2. maximumPoolSize 能容纳的最大线程数
    • 即当阻塞队列已满时,并且当前线程池线程个数没有超过 maximumPoolSize 的话,就会创建新的线程来执行任务。
  3. keepAliveTime 空闲线程存活时间
    • 如果当前线程池的线程个数已经超过了 corePoolSize,并且线程空闲时间超过了 keepAliveTime 的话,就会将这些空闲线程销毁,这样可以尽可能降低系统资源消耗。
  4. unit 存活的时间单位
  5. workQueue 存放提交但未执行任务的队列,即阻塞队列
  6. threadFactory 创建线程的工厂类
  7. handler 等待队列满后的拒绝策略

线程池中,有三个重要的参数,决定影响了拒绝策略:

  1. corePoolSize - 核心线 程数,也即最小的线程数。
  2. workQueue - 阻塞队列 。
  3. maximumPoolSize - 最大线程数 当提交任务数大于 corePoolSize 的时候,会优先将任务放到 workQueue 阻塞队列中。当阻塞队列饱和后,会扩充线程池中线程数,直到达到 maximumPoolSize 最大线程数配置。此时,再多余的任务,则会触发线程池 的拒绝策略了。 总结起来,也就是一句话,当提交的任务数大于(workQueue.size() + maximumPoolSize ),就会触发线程池的拒绝策略。

6)拒绝策略

  1. AbortPolicy: 丢弃任务,并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常,否则会打断当前的执行流程,影响后续的任务执行。

  2. CallerRunsPolicy: 当触发拒绝策略,只要线程池没有关闭的话,则使用调用线程直接运行任务。一般并发比较小,性能要求不高,不允许失败。但是,由 于调用者自己运行任务,如果任务提交速度过快,可能导致程序阻塞,性能效 率上必然的损失较大

  3. DiscardPolicy: 直接丢弃.

  4. DiscardOldestPolicy: 触发拒绝策略时,只要线程池没有关闭的话,丢弃阻塞队列 workQueue中最老的任务,并将新任务加入

🧇线程池种类

Jav有4种默认线程池,分别是

2.1、 newCachedThreadPool

作用:创建一个可缓存线程池,此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程.

比较适合用于创建一个可无限扩大的线程池,执行时间较短,任务多的场景。

特点

  1. 线程池中数量不固定,可以达到(Interger. MAX_VALUE)
  2. 线程池中的线程可进行缓存重复利用和回收(回收默认时间为 1 分钟,即1分钟内没有任务的线程)。

创建方式

/**
     * 可缓存线程池
     * @return
     */
public static ExecutorService newCachedThreadPool() {
    /**
        * corePoolSize 线程池的核心线程数
        * maximumPoolSize 能容纳的最大线程数
        * keepAliveTime 空闲线程存活时间
        * unit 存活的时间单位
        * workQueue 存放提交但未执行任务的队列
        * threadFactory 创建线程的工厂类:可以省略
        * handler 等待队列满后的拒绝策略:可以省略
        */
    return new ThreadPoolExecutor(0,
                                  Integer.MAX_VALUE,
                                  60L,
                                  TimeUnit.SECONDS,
                                  new SynchronousQueue<>(),
                                  Executors.defaultThreadFactory(),
                                  new ThreadPoolExecutor.AbortPolicy());
}
复制代码

2.2、newFixedThreadPool

作用

用来创建一个可重用固定线程数的线程池,以共享的无界队列(LinkedBlockingQueue)方式来运行这些线程。

适用于预测并发压力的情况下,对线程数做出限制;或者对线程数有严格限制的场景

特点

  1. 线程数固定可重用。
  2. corePoolSize和maximunPoolSize设定值相等。
  3. keepAliveTime为0,一旦有多余的空闲线程,就会被立即停止掉。
  4. 阻塞队列采用了LinkedBlockingQueue,它是一个无界队列,因此永远不可能拒绝任务,超出的任务都需在队列中等待。

创建方式

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
复制代码

2.3、newSingleThreadExecutor

作用

创建一个使用单个 worker 线程的 Executor,以无界队列(LinkedBlockingQueue)方式来运行该线程。超出的任务都将存储在队列中,等待执行。

适用于需要保证顺序执行各个任务,并且在任意时间点,不会同时有多个线程的场景

特点

线程池中最多执行 1 个线程,之后提交的线程活动将会排在队列中以此 执行

创建方式

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
复制代码

2.4、newScheduledThreadPool

作用

创建一个 corePoolSize 为传入参数,最大线程数为(Integer.MAX_VALUE)的线程池,此线程池支持定时以及周期性执行任务的需求。

比较适用于需要多个后台线程执行周期任务的场景,某个时候要收集日志了,发送推送消息拉等等都很合适😂

特点

可定时或延迟执行线程活动~~(我拿这个模拟过动态定时,意思是给定个未来某个时间,然后到那个时间点就执行)~~

创建方式

public static ScheduledExecutorService newScheduledThreadPool(
    int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
    
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}
复制代码

🍖入门案例

火车站 3 个售票口, 10 个用户买票

import java.util.concurrent.*;

/**
 * 入门案例
 */
public class ThreadPoolDemo1 {


    /**
     * 火车站 3 个售票口, 10 个用户买票
     *
     * @param args
     */
    public static void main(String[] args) {
        //定时线程次:线程数量为 3---窗口数为 3
        ExecutorService threadService = new ThreadPoolExecutor(3,
                3,
                60L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        try {
            //10 个人买票
            for (int i = 1; i <= 10; i++) {
                threadService.execute(() -> {
                    try {
                        System.out.println(Thread.currentThread().getName() + " 窗口,开始卖票");
                        Thread.sleep(500);
                        System.out.println(Thread.currentThread().getName() + " 窗口买票结束");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //完成后结束
            threadService.shutdown();
        }
    }
}
/**
 pool-1-thread-3 窗口,开始卖票
 pool-1-thread-2 窗口,开始卖票
 pool-1-thread-1 窗口,开始卖票
 pool-1-thread-3 窗口买票结束
 pool-1-thread-2 窗口买票结束
 pool-1-thread-1 窗口买票结束
 ....
 */
复制代码

🍤线程池底层工作原理(重要)

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
   //如果线程池的线程个数少于corePoolSize则创建新线程执行当前任务
    if (workerCountOf(c) < corePoolSize) {
        //执行addworker,创建一个核心线程,创建失败重新获取ctl
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
//如果工作线程数大于核心线程数,判断线程池的状态是否为running,并且可以添加进队列
//如果线程池不是running状态,则执行拒绝策略,(还是会调用一次addworker)
    if (isRunning(c) && workQueue.offer(command)) {
         //再次获取ctl,进行双重检索
        int recheck = ctl.get();
        //如果线程池是不是处于RUNNING的状态,那么就会将任务从队列中移除, 
        //如果移除失败,则会判断工作线程是否为0 ,如果过为0 就创建一个非核心线程 
        //如果移除成功,就执行拒绝策略,因为线程池已经不可用了;
        if (! isRunning(recheck) && remove(command))
            //为给定的命令调用被拒绝的执行处理程序
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
   //检查是否可以根据当前池状态和给定界限(核心或最大值)添加新的工作线程。 
   //如果是这样,则相应地调整工作人员数量,并且如果可能,将创建并启动一个新工作人员,将 firstTask 作为其第一个任务运行。 
   //如果池已停止或有资格关闭,则此方法返回 false。 
   //如果线程工厂在询问时未能创建线程,它也会返回 false。 
   //如果线程创建失败,要么是由于线程工厂返回 null,要么是由于异常(通常是 Thread.start() 中的 OutOfMemoryError),我们会干净利落地回滚。
    else if (!addWorker(command, false))
        // 为给定的命令调用被拒绝的执行处理程序
        reject(command);
}
复制代码

execute执行过程示意图.jpg

上图取自:线程池ThreadPoolExecutor实现原理 作者:你听___

execute执行逻辑

  1. 在创建了线程池后,线程池中的线程数为零
  2. 当调用 execute()方法添加一个请求任务时,线程池会做出如下判断:
    • 如果正在运行的线程数量小于 corePoolSize,那么马上创建线程运行这个任务;
    • 如果正在运行的线程数量大于或等于 corePoolSize,那么将这个任务放入 队列;
    • 如果这个时候队列满了且正在运行的线程数量还小于 maximumPoolSize,那么还是要创建非核心线程立刻运行这个任务;
    • 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize,那么线程 池会启动饱和拒绝策略来执行。
  3. 当一个线程完成任务时,它会从队列中取下一个任务来执行
  4. 当一个线程无事可做超过一定的时间(keepAliveTime)时,线程会判断:
    1. 如果当前运行的线程数大于 corePoolSize,那么这个线程就被停掉。
    2. 所以线程池的所有任务完成后,它最终会收缩到 corePoolSize 的大小。

🍦注意事项

创建线程池推荐适用 ThreadPoolExecutor 及其 7 个参数手动创建

为什么不使用Executors创建?

image-20210822202445905.png

🍕自言自语

最近又开始了JUC的学习,感觉Java内容真的很多,但是为了能够走的更远,还是觉得应该需要打牢一下基础。

最近在持续更新中,如果你觉得对你有所帮助,也感兴趣的话,关注我吧,让我们一起学习,一起讨论吧。

你好,我是博主宁在春,Java学习路上的一颗小小的种子,也希望有一天能扎根长成苍天大树。

希望与君共勉😁

我们:待别时相见时,都已有所成

参考:

线程池ThreadPoolExecutor实现原理

www.zhihu.com/question/23… 作者:大闲人柴毛毛

阿里巴巴开发手册

分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改