线程池学习

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量94 收藏
点赞数
分类专栏： 线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yezhazhang1772/article/details/109023944
版权

1.线程池的处理流程

在这里插入图片描述

注意点：核心线程池已满时需要将任务加入阻塞队列，如果阻塞队列满才看线程池的最大线程数量

2. 线程池可选择的阻塞队列

public void blockingQueueTest(){

        /**
         * 基于数组的有界的阻塞队列，容量为10
         */
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        /**
         * 基于链表的 无界（不传值的构造函数） / 有界 （传参） 的阻塞队列
         */
        LinkedBlockingDeque<Integer> linkedBlockingDeque = new LinkedBlockingDeque<>();

    }
    
    @Test
    public void synchronousQueue() throws InterruptedException {

        /**
         * 同步移交阻塞队列，没有存储数据的能力, 一对一的队列， 基于线程的，一个线程插入，一个线程移除
         */
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        // 构建插入值的线程
        new Thread(() -> {
            try {
                queue.put(1);
                System.out.println("插入成功");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();


        /*  注释后， 无 插入成功打印， 因为该队列是一对一的方式
        // 删除值
        new Thread(() -> {
            try {
                queue.take();
                System.out.println("删除成功");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        */

        Thread.sleep(1000L * 10);
    }

3. 线程池可选择的饱和策略

注：阻塞队列和最大线程池已经满后

在这里插入图片描述

4. 线程池执行示意图

在这里插入图片描述
创建线程池方法详解

5. 线程池提交任务

// 1. submit方法, 可以接收任务的返回结果，接收到结果后继续执行
public void submitTest() throws ExecutionException, InterruptedException {

        // 创建线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();

        /**
         * 使用 submit 方法提交任务，接收任务的返回结果
         */
        Future<Integer> future = threadPool.submit(() -> {
            Thread.sleep(1000L * 10);

            return 2 * 5;
        });

        /**
         * 阻塞方法，需要得到返回值后才继续执行
         */
        Integer integer = future.get();

        System.out.println("执行结果是： " + integer);

    }

	// 2. execute方法，提交任务, 没有返回值
    public void executeTest() throws InterruptedException {

        // 创建线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        // execute 提交任务, 没有返回值
        threadPool.execute(() ->{
            try {
                Thread.sleep(1000L * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Integer num = 2 * 5;
            System.out.println("执行结果：" + num);
        });
        Thread.sleep(1000L * 1000);
    }

6. 线程池的状态

在这里插入图片描述

注： shutdown 方法 与 shutdownNow方法

7. 演示线程池的四种饱和策略

public class PolicyTest {

    // 创建一个线程池
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            // 核心线程2 最大线程3
            2, 3,
            // 有界的阻塞队列
            60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(5));


    /**
     * 任务
     */
    class Task implements Runnable{

        /**
         * 任务名称
         */
        private String taskName;

        public Task(String taskName){
            this.taskName = taskName;
        }

        @Override
        public void run() {
            // 线程执行方法
            System.out.println("线程["+ Thread.currentThread().getName() +"]正在执行["
                    + taskName + "]任务...");
            try {
                Thread.sleep(1000L*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程["+ Thread.currentThread().getName() +"]已经执行完["
                    + taskName + "]任务！！！");
        }
    }

    /**
     * 线程池的执行过程：
     *  2 个核心线程
     *  5 个任务队列
     *  3 个最大线程：除核心线程后 1个线程可用
     *
     *  前2个任务，占用核心线程执行
     *  第3 到 第7个任务，会暂存到任务队列中
     *  第8个任务 启动最大线程执行
     *
     *  第9个任务，没有线程执行，会启动饱和策略执行
     */

    /**
     * 单元测试执行完，主线程等待100秒，防止主线程退出
     */
    @After
    public void after() throws InterruptedException {
        Thread.sleep(1000L * 100);
    }

}
7.1 终止饱和策略
    /**
     * 终止策略，拒接任务提交
     */
    @Test
    public void abortPolicyTest(){

        // 设置饱和策略为 终止策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());

        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

执行结果：
在这里插入图片描述

7.2 丢弃策略
    @Test
    public void discardPolicyTest(){
        // 设置饱和策略为 丢弃策略，丢弃最后的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

执行结果：
在这里插入图片描述

7.3 丢弃旧任务策略
    /**
     * 抛弃旧任务策略
     * TODO 丢弃掉任务队列中的旧任务，暂存新提交的任务
     */
    @Test
    public void discardOldestPolicyTest(){
        // 设置饱和策略为 丢弃策略，丢弃最后的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

执行结果：
在这里插入图片描述

7.4 调用者运行策略
/**
     * 调用者运行策略
     * TODO 借用主线程来执行多余任务
     */
    @Test
    public void callerRunsPolicyTest(){
        // 设置饱和策略为 丢弃策略，丢弃最后的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

执行结果：
在这里插入图片描述

所有测试代码
public class PolicyTest {

    // 创建一个线程池
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(
            // 核心线程2 最大线程3
            2, 3,
            // 有界的阻塞队列
            60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(5));


    /**
     * 任务
     */
    class Task implements Runnable{

        /**
         * 任务名称
         */
        private String taskName;

        public Task(String taskName){
            this.taskName = taskName;
        }

        @Override
        public void run() {
            // 线程执行方法
            System.out.println("线程["+ Thread.currentThread().getName() +"]正在执行["
                    + taskName + "]任务...");
            try {
                Thread.sleep(1000L*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程["+ Thread.currentThread().getName() +"]已经执行完["
                    + taskName + "]任务！！！");
        }
    }

    /**
     * 线程池的执行过程：
     *  2 个核心线程
     *  5 个任务队列
     *  3 个最大线程：除核心线程后 1个线程可用
     *
     *  前2个任务，占用核心线程执行
     *  第3 到 第7个任务，会暂存到任务队列中
     *  第8个任务 启动最大线程执行
     *
     *  第9个任务，没有线程执行，会启动饱和策略执行
     */

    /**
     * 终止策略，拒接任务提交
     */
    @Test
    public void abortPolicyTest(){

        // 设置饱和策略为 终止策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());

        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

    @Test
    public void discardPolicyTest(){
        // 设置饱和策略为 丢弃策略，丢弃最后的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

    /**
     * 抛弃旧任务策略
     * TODO 丢弃掉任务队列中的旧任务，暂存新提交的任务
     */
    @Test
    public void discardOldestPolicyTest(){
        // 设置饱和策略为 丢弃策略，丢弃最后的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

    /**
     * 调用者运行策略
     * TODO 借用主线程来执行多余任务
     */
    @Test
    public void callerRunsPolicyTest(){
        // 设置饱和策略为 丢弃策略，丢弃最后的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 创建线程执行
        for (int i = 1; i <= 10 ; i++) {
            try {
                executor.execute(new Task("线程任务" + i));
            }catch (Exception e){
                System.err.println(e);
            }
        }
        // 线程池关闭
        executor.shutdown();
    }

    /**
     * 单元测试执行完，主线程等待100秒，防止主线程退出
     */
    @After
    public void after() throws InterruptedException {
        Thread.sleep(1000L * 100);
    }

}
yezhazhang1772
关注
专栏目录
学习一把线程池
qq_40707269的博客
10-13 65
为了避免线程资源不能重复使用，太浪费了，所以建立线程池，每次从里面拿完线程，用完了还回去，让线程不会死去 1.使用线程生产工具类Exectors类，中static ExectorService newFixedTheadPool(int nThreads)方法，建立一个线程池 返回一个ExctorService接口的实现类 2.使用submit（Runnable )往里面传一个Runnable接口实现的对象，设置线程任务 package com.company.LearnThread; import ja
对于线程池的一些学习
MDY的博客
06-01 369
ThreadPoolExecutor线程池是什么，作用：线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。Thread与Runable的用法 class MyThread ext
【Java并发学习一】如何实现一个线程池
热门推荐
大树的学习之路
01-17 1万+
前言 和设计模式一样，打算花三个月的时间，结合《Java并发编程实战》一书，来总结下并发方面的知识。第一章从线程池的原理开始总结，希望自己能坚持下来，加油！ 1. 如何实现一个线程池？ 线程池的概念这里不多说，在讲它的原理前，我们先自己想一下，如果我来写，那如何实现一个线程池？ 1.1 线程池的重要变量 首先要定义一个存放所有线程的集合； 另外，每有一个任务分配给线程池，我们就
java线程池学习--1
03-16
NULL 博文链接：https://lhgyy00.iteye.com/blog/450628
六、进程池与线程池学习ppt
06-11
【进程池与线程池学习】是计算机编程中并发处理的重要概念，主要涉及多线程和多进程的高效管理。在分布式系统、网络编程以及大数据处理等领域，进程池和线程池的应用尤为广泛。 首先，我们需要理解进程和线程的基本...
Java线程池学习资料-全
08-11
Java线程池是一种高效管理并发任务的工具，它通过复用线程来减少创建和销毁线程的开销，从而提高系统性能。线程池的核心组成部分包括工作队列（Work Queue）、工作线程（Worker Threads）和任务调度器（Executor）。...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1119
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 157
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 892
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 928
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 349
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1210
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 854
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1073
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 422
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
JAVA开源项目 在线视频教育平台 计算机毕业设计
as230627的博客
09-14 1053
基于Vue.js和SpringBoot的在线视频教育平台是一个功能丰富的系统，它包括管理后台和用户网页端，为管理员、普通用户和教师角色提供了不同的功能。在管理后台，管理员可以进行用户管理，包括用户信息的增删改查。
JAVA——方法重载
bengbeng2345的博客
09-12 211
返回值不能作为重载条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值