JUC_线程池

谁借莪１个温暖的怀抱￠ 2023-07-03 03:21 166阅读 0赞

文章目录

  • 为什么使用线程池
  • 使用说明
    • 架构说明
    • 编码实现
      • Executors.newFixedThreadPool(int)
      • Executors.newSingleThreadExecutor()
      • Executors.newCachedThreadPool()
  • 线程池七大参数
  • 线程池底层工作原理
  • 利用何种方法创建线程池
  • 拒绝策略
  • 如何合理配置线程池
    • CPU密集型
    • IO密集型

为什么使用线程池

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

它的主要特点为：线程复用;控制最大并发数;管理线程。

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

使用说明

架构说明

在这里插入图片描述

编码实现

Executors.newFixedThreadPool(int)

执行长期任务性能好，创建一个线程池，一池有N个固定的线程，有固定线程数的线程

  1. public static ExecutorService newFixedThreadPool(int nThreads) {
  3.     return new ThreadPoolExecutor(nThreads, nThreads,
  4.                                   0L, TimeUnit.MILLISECONDS,
  5.                                   new LinkedBlockingQueue<Runnable>());
  6. }

newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的是LinkedBlockingQueue。

Executors.newSingleThreadExecutor()

一个任务一个任务的执行，一池一线程

  1. public static ExecutorService newSingleThreadExecutor() {
  3.     return new FinalizableDelegatedExecutorService
  4.         (new ThreadPoolExecutor(1, 1,
  5.                                 0L, TimeUnit.MILLISECONDS,
  6.                                 new LinkedBlockingQueue<Runnable>()));
  7. }

newSingleThreadExecutor 创建的线程池corePoolSize和maximumPoolSize值都是1，它使用的是LinkedBlockingQueue

Executors.newCachedThreadPool()

执行很多短期异步任务，线程池根据需要创建新线程，但在先前构建的线程可用时将重用它们。可扩容，遇强则强

  1. public static ExecutorService newCachedThreadPool() {
  3.     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
  4.                                   60L, TimeUnit.SECONDS,
  5.                                   new SynchronousQueue<Runnable>());
  6. }

newCachedThreadPool创建的线程池将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，它使用的是SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。

线程池七大参数

  1. public ThreadPoolExecutor(int corePoolSize,
  2.                           int maximumPoolSize,
  3.                           long keepAliveTime,
  4.                           TimeUnit unit,
  5.                           BlockingQueue<Runnable> workQueue,
  6.                           ThreadFactory threadFactory,
  7.                           RejectedExecutionHandler handler) {
  9.     if (corePoolSize < 0 ||
  10.         maximumPoolSize <= 0 ||
  11.         maximumPoolSize < corePoolSize ||
  12.         keepAliveTime < 0)
  13.         throw new IllegalArgumentException();
  14.     if (workQueue == null || threadFactory == null || handler == null)
  15.         throw new NullPointerException();
  16.     this.corePoolSize = corePoolSize;
  17.     this.maximumPoolSize = maximumPoolSize;
  18.     this.workQueue = workQueue;
  19.     this.keepAliveTime = unit.toNanos(keepAliveTime);
  20.     this.threadFactory = threadFactory;
  21.     this.handler = handler;
  22. }
  1. corePoolSize：线程池中的常驻核心线程数
  2. maximumPoolSize：线程池中能够容纳同时执行的最大线程数，此值必须大于等于1
  3. keepAliveTime：多余的空闲线程的存活时间,当前池中线程数量超过corePoolSize时，当空闲时间,达到keepAliveTime时，多余线程会被销毁直到,只剩下corePoolSize个线程为止
  4. unit：keepAliveTime的单位
  5. workQueue：任务队列，被提交但尚未被执行的任务
  6. threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可
  7. handler：拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时如何来拒绝请求执行的runnable的策略

线程池底层工作原理

  1. 线程池创建之后，等待请求

  2. 当调用execute()方法添加一个请求任务时，线程池将作出以下判断：

    1. 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务
    2. 如果正在运行的线程数量大于等于corePoolSize，那么将这个任务放入队列
    3. 如果队列已满并且运行的线程数量小于maximumPoolSize，则创建非核心线程立刻执行这个任务
    4. 如果队列满了，且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行
  3. 当一个线程完成任务时，它会从队列中取下一个任务来执行

  4. 当一个线程空闲超过keepAlivetime时，会做以下判断：

    1. 如果当前运行线程数量大于corePoolSize，那么这个线程将被停掉。所有任务完成后，最终会收缩到corePoolSize的大小。

利用何种方法创建线程池

在这里插入图片描述

  1. ExecutorService threadPool = new ThreadPoolExecutor(
  2.         2,
  3.         5,
  4.         2L,
  5.         TimeUnit.SECONDS,
  6.         new ArrayBlockingQueue<Runnable>(3),
  7.         Executors.defaultThreadFactory(),
  8.         new ThreadPoolExecutor.DiscardOldestPolicy()
  9. );

拒绝策略

  • AbortPolicy(默认):直接抛出RejectedException异常阻止系统正常运行
  • CallerRunPolicy:”调用者运行”一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将任务回退到调用者，从而降低新任务的流量
  • DiscardOldestPolicy:抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交
  • DiscardPolicy:直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略

如何合理配置线程池

https://blog.csdn.net/Chill_Lyn/article/details/106878028

CPU密集型

  1. //查看CPU核数
  2. System.out.println(Runtime.getRuntime().availableProcessors());

任务需要大量的运算，且没有阻塞，CPU一直全速运行，这种情况下应该尽可能减少线程之间上下文切换带来的开销，一般为CPU核数+1

IO密集型

任务需要大量的IO，即大量的阻塞。在单线程上运行IO密集型任务会导致浪费大量的CPU运算能力在等待。所以在IO密集型任务重使用多线程可以大大加速程序运行，即使再单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。

  1. 线程数=CPU核数×（1/CPU利用率）=CPU核数×[1+（IO耗时/CPU耗时）]

发表评论

表情：
评论列表 （有 0 条评论，166人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JUC-线程池

    ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量。这些信息存储在原子变量ctl中，将线程状态与线程数合二为一，这...

    骑猪看日落骑猪看日落/ 0 赞/ 224 阅读

    相关 JUC包(五) 线程池

    前言 在前面的篇章中.我们将解了`线程/锁/多线程容器`.本章我们将介绍一个用于管理线程的容器:`线程池`. -------------------- 正文 线

    心已赠人心已赠人/ 0 赞/ 413 阅读