JUC并发编程（八）-- 线程池

最新推荐文章于 2023-08-03 11:20:10 发布
最新推荐文章于 2023-08-03 11:20:10 发布
阅读量376 收藏 4
点赞数 2
分类专栏： 多线程 java 文章标签： juc 多线程 thread java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43827693/article/details/110695956
版权

JUC并发编程（八）-- 线程池

池化技术

我们知道，程序的运行，本质是占用系统的资源，那为了优化资源的时候，就出现了池化技术！
常见的有：线程池、内存池、对象池 等待…
一句话总结池化技术：事先准备好一些资源，有人需要用，就来找我拿，用完还要还给我。

线程池的优点

  1. 降低资源的消耗；
  2. 提高响应的速度；
  3. 方便管理。

线程复用、可以控制连接数、最大并发数等等，管理线程

线程池的用法

三大方法，七大参数、四种拒绝策略
在这里插入图片描述

一、三大方法

虽说阿里开发手册上，强制不允许使用Executors创建，但目前我们处于demo阶段，所以这里的三大方法我们还是用Executros来demo。

1、创建单个线程的线程池

上代码：

package com.zhan.juc.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author Zhanzhan
 * @Date 2020/12/5 16:34
 * Executors工具类  -- 三大方法
 */
public class ExecutorsDemo {

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);// 创建一个固定大小的线程池
//        ExecutorService threadPool = Executors.newCachedThreadPool();// 创建一个可伸缩的线程池

        try {
            for (int i = 0; i < 10; i++) {
                // 使用了线程池后，就用线程池来创建线程
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 创建");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完，程序结束，要关闭线程池
            threadPool.shutdown();
        }
    }
}

运行结果：
在这里插入图片描述
我们可以看到，循环创建10个线程，都是同一个线程，即用此方法创建的线程池，内部是单个线程。

2、创建一个固定大小的线程池

上代码：

package com.zhan.juc.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author Zhanzhan
 * @Date 2020/12/5 16:34
 * Executors工具类  -- 三大方法
 */
public class ExecutorsDemo {

    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
        ExecutorService threadPool = Executors.newFixedThreadPool(5);// 创建一个固定大小的线程池
//        ExecutorService threadPool = Executors.newCachedThreadPool();// 创建一个可伸缩的线程池

        try {
            for (int i = 0; i < 10; i++) {
                // 使用了线程池后，就用线程池来创建线程
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 创建");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完，程序结束，要关闭线程池
            threadPool.shutdown();
        }
    }
}

运行结果：
在这里插入图片描述
我们看到，循环10次，里面始终只有5个线程。

3、创建一个可伸缩的线程池

上代码：

package com.zhan.juc.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author Zhanzhan
 * @Date 2020/12/5 16:34
 * Executors工具类  -- 三大方法
 */
public class ExecutorsDemo {

    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);// 创建一个固定大小的线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();// 创建一个可伸缩的线程池

        try {
            for (int i = 0; i < 10; i++) {
                // 使用了线程池后，就用线程池来创建线程
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 创建");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完，程序结束，要关闭线程池
            threadPool.shutdown();
        }
    }
}

运行结果：
在这里插入图片描述
我们看到，这里循环10次，没有固定说开启了几个线程，而是根据情况，由程序自己去开启。

二、七大参数

我们首先看下，上面说的三大方法里，创建对应线程池的源码：

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

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

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

我们神奇的发现，内部其实都是new 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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

这里解释下最大核心线程数：就是当核心线程全部在执行任务，并且阻塞队列里的线程也占满了队列，这时就会启动扩容核心线程，直到扩容到最大核心线程数。
那么我们就可以知道，线程池的最大承载量是多少呢？就是最大核心线程数 + 阻塞队列的容量。一旦超过这个承载量，后进入的线程就会启动拒绝策略。

上面的七个参数就是七大参数，现在我们就用ThreadPoolExectors来自定义一个线程池，并且用上这七个参数：

package com.zhan.juc.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author Zhanzhan
 * @Date 2020/12/5 17:08
 * 七大参数、四种拒绝策略
 */
public class ThreadPoolExecutorsDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,  // 核心线程数
                5,  // 最大核心线程数
                3, // 超时了没有人调用就会释放，指定超时时间
                TimeUnit.SECONDS, // 超时单位
                new LinkedBlockingQueue<>(3), // 阻塞队列，这里指定阻塞队列的容量为3
                Executors.defaultThreadFactory(), // 线程工厂，一般不用动, 就使用 Executors.defaultThreadFactory()
                new ThreadPoolExecutor.AbortPolicy()); // 拒绝策略

        try {
            for (int i = 0; i < 8; i++) {
                // 使用了线程池后，就用线程池来创建线程
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 创建");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoolExecutor.shutdown(); // 线程池用完，程序结束，要关闭线程池
        }
    }
}

三、四种拒绝策略

我们看ThreadPoolExecutors的源码：
在这里插入图片描述
我们看到，RejectedExecutionHandler类是一个拒绝策略的接口类，我们进入这个类看下：
在这里插入图片描述
我们看到，有四个实现类，这四个实现类分别就是四种拒绝策略：

1. AbortPolicy

如果队列满了，还有线程进来，则不处理这个线程，并抛出异常；
上代码：

package com.zhan.juc.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author Zhanzhan
 * @Date 2020/12/5 17:08
 * 七大参数、四种拒绝策略
 */
public class ThreadPoolExecutorsDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,  // 核心线程数
                5,  // 最大核心线程数
                3, // 超时了没有人调用就会释放，指定超时时间
                TimeUnit.SECONDS, // 超时单位
                new LinkedBlockingQueue<>(3), // 阻塞队列，这里指定阻塞队列的容量为3
                Executors.defaultThreadFactory(), // 线程工厂，一般不用动, 就使用 Executors.defaultThreadFactory()
                new ThreadPoolExecutor.AbortPolicy()); // 拒绝策略

        try {
            // 线程池的最大承载量 = 最大核心线程数 + 阻塞队列容量
            for (int i = 0; i < 9; i++) {
                // 使用了线程池后，就用线程池来创建线程
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 创建");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完，程序结束，要关闭线程池
            threadPoolExecutor.shutdown();
        }
    }
}

我们这里让循环超过最大承载量，看运行结果：
在这里插入图片描述

2. CallerRunsPolicy

哪儿来的去哪儿！
上代码：
这里同样超出线程池承载量

package com.zhan.juc.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author Zhanzhan
 * @Date 2020/12/5 17:08
 * 七大参数、四种拒绝策略
 */
public class ThreadPoolExecutorsDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,  // 核心线程数
                5,  // 最大核心线程数
                3, // 超时了没有人调用就会释放，指定超时时间
                TimeUnit.SECONDS, // 超时单位
                new LinkedBlockingQueue<>(3), // 阻塞队列，这里指定阻塞队列的容量为3
                Executors.defaultThreadFactory(), // 线程工厂，一般不用动, 就使用 Executors.defaultThreadFactory()
                new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略

        try {
            // 线程池的最大承载量 = 最大核心线程数 + 阻塞队列容量
            for (int i = 0; i < 9; i++) {
                // 使用了线程池后，就用线程池来创建线程
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 创建");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完，程序结束，要关闭线程池
            threadPoolExecutor.shutdown();
        }
    }
}

运行结果：
在这里插入图片描述
原因就是：此拒绝策略，就是超出后，从谁那里创建的，就回那里去执行，这里是main() 去创建的，所以就回去让main() 去执行此线程了。

3. DiscardOldestPolicy

队列满了，尝试和最早的竞争，如果最早的线程执行完毕，就可以跟上执行，否则则丢掉，不会抛出异常；

4. DiscardPolicy

队列满了，丢掉任务，也不会抛出异常。
上代码：

package com.zhan.juc.pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author Zhanzhan
 * @Date 2020/12/5 17:08
 * 七大参数、四种拒绝策略
 */
public class ThreadPoolExecutorsDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,  // 核心线程数
                5,  // 最大核心线程数
                3, // 超时了没有人调用就会释放，指定超时时间
                TimeUnit.SECONDS, // 超时单位
                new LinkedBlockingQueue<>(3), // 阻塞队列，这里指定阻塞队列的容量为3
                Executors.defaultThreadFactory(), // 线程工厂，一般不用动, 就使用 Executors.defaultThreadFactory()
                new ThreadPoolExecutor.DiscardPolicy()); // 拒绝策略

        try {
            // 线程池的最大承载量 = 最大核心线程数 + 阻塞队列容量
            for (int i = 0; i < 9; i++) {
                // 使用了线程池后，就用线程池来创建线程
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 创建");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 线程池用完，程序结束，要关闭线程池
            threadPoolExecutor.shutdown();
        }
    }
}

运行结果：
在这里插入图片描述
这里丢掉了超出承载量的线程任务。

四、线程池的容量该如何定义

这里我们要考虑一个问题，就是创建线程池时，线程池的最大线程数该如何定义？是拍脑袋随便定义的吗？
这样的话可能会浪费线程资源。这个时候我们就需要找到一个定义最大线程数的方法。

1、CPU密集型

就是充分利用CPU的核数，让CPU的所有核心全部并行运算处理。
这样适用于需要大量的运算，而没有阻塞，CPU一直全速运行的场景。
所以，CPU密集型 的 最大线程数 公式为：CPU核数 + 1

这里可以使用Runtime.getRuntime().availableProcessors() 来获取当前服务器的核数，来作为最大线程数的参数。

2、I/O密集型

如果是 比较耗费 I/O 的任务场景，那么这时就需要 使用 I/O密集型 来配置线程。

我们知道，CPU的运算速度是很快的，比 I/O 的速度要快很多，那么如果是十分消耗 I/O的场景，这个时候CPU的每个单核会在很长的时间段上一直阻塞等待I/O的处理，这个时候，我们如果使用CPU密集型，给每个CPU的单核分配一个线程，这个时候CPU的单核就处于无意义的阻塞中，浪费时间，所以这个时候的最大线程数就要比CPU密集型要多。

一般我们这时的参考公式为：CPU核数 / (1 - 阻塞系数)
阻塞系数一般在 0.5 - 0.9之间，我们常用的就是 2倍CPU密集型 线程数。

书生灬今天不吃饭
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java并发编程：juc线程池
08-09
而了解 Java 并发编程以及其中的 JUC（java.util.concurrent）线程池，对于构建高性能、高可伸缩性的应用程序具有重要意义。 多核处理器的出现使得并发执行成为一种重要的优化手段。了解并发编程和线程池的工作原理...
JUC并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
JUC并发编程
qq_45767346的博客
04-04 443
阻塞队列，顾名思义，首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；当队列是空的，从队列中获取元素的操作将会被阻塞。当队列是满的，从队列中添加元素的操作将会被阻塞。试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素。试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增。
【并发编程】JUC并发编程（彻底搞懂JUC）
DreamSun的博客
03-29 6239
JUC实际上就是我们对于jdk中java.util .concurrent 工具包的简称，其结构如下：这个包下都是Java处理线程相关的类，自jdk1.5后出现。目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！JUC主要是指JDK8中java.util.concurrent里提供的一系列线程并发工具，但是线程并发的问题远不止几个工具这么简单。要学习工具使用，更要能深入理解工具的原理以及处理线程并发问题的思路。
juc并发编程
王举
11-06 385
一种抽象的概念模型，并不是真实存在，它仅仅是一组约定或规范，通过这组规范定义了程序中各个变量的读写访问方式并决定一个线程对共享变量的写入何时以及如何变成对另一个线程可见，关键技术都是围绕多线程的原子性，可见性和有序性展开JMM作用：1.实现线程和主内存之间的抽象关系，2.屏蔽各个硬件平台和操作系统的内存访问差异以实现让java程序在各种平台上都能达到一致的内存访问效果。
JUC线程池
weixin_53455615的博客
08-25 650
java.util.concurrent包（简称：JUC）。JUC主要是让开发者在多线程编程中更加简单、方便一些。通过JDK内置了一些类、接口、关键字，补充完善了JDK对于并发编程支持的“短板”。（1）Executor：线程池（2）Atomic：原子操作类（3）Lock：锁（4）Tools：信号量工具类（4）并发集合：提供了线程安全的集合类。
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
Java-并发（Concurrent）编程
07-15
并发编程：编写多线程代码，解决多线程带来的问题 为什么要学并发编程？ 首先，来看一个案例：手写网站服务器案例。 高性能应用程序的一把钥匙，应用程序的翅膀，面试高频的考点 中间件几乎都是多线程应用：MySQL、...
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
Java高并发核心编程(JUC)—线程池详细笔记
Cheney的博客
05-22 1151
线程池：一个容纳多个线程的容器，容器中的线程可以重复使用，省去了频繁创建和销毁线程对象的操作降低资源消耗，减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务提高响应速度，当任务到达时，如果有线程可以直接用，不会出现系统僵死提高线程的可管理性，如果无限制的创建线程，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控线程复用，同一个线程可以被重复使用，来处理多个任务。
JUC 并发编程
qq_43649937的博客
04-01 437
java
【JUC基础】12. 线程池（一）
有一只柴犬的专栏
05-31 1193
我们知道多线程的使用，是为了最大限度发挥现代多核处理器的计算能力，提高系统的吞吐量和性能。但是如果不加以控制和管理，随意使用多线程，对系统性能反而会有不利的影响。线程数量和系统CPU资源是息息相关的，随意使用甚至可能会耗尽系统CPU资源和内存资源。
JUC并发编程详解
cqdddgs的博客
08-03 295
completion stage:代表异步计算过程中的某个阶段一个阶段完成以后可能会触发另一个阶段在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组completableFuture 的方法。它可能代表一个明确完成的Future，也有可能代表一个完成阶段〈CompletionStage )，它支持在计算完成以后触发一些函数或执行某些动作。
juc并发编程线程池
最新发布
06-18
线程池是并发编程中常用的一种机制，它允许您预先创建一组线程，并在需要执行任务时重用这些线程，从而提高性能和资源管理。 `Executors`类提供了一些预定义的线程池工厂方法，如`newFixedThreadPool()`, `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值