java 线程池

一.简单的线程池设计：

在这里插入图片描述
线程池的执行示意图：
在这里插入图片描述

二. 线程池的核心参数：

在这里插入图片描述

三.线程池的处理流程：

在这里插入图片描述

四.线程池的阻塞队列：

1.基于数组的有界阻塞队列
2.基于链表的有界阻塞队列
3.基于链表的无界阻塞队列
4.同步移交阻塞队列

1.基于数组的有界阻塞队列：

public static void main(String[] args) throws InterruptedException {
        // 创建一个有界队列，队列容量为10
        ArrayBlockingQueue queue = new ArrayBlockingQueue<Integer>(10);
        // 循环向队列添加元素
        for (int i = 0; i < 20; i++) {
            queue.put(i);
            System.out.println("向队列中添加值:" + i);
        }
    }

到了第10个就阻塞不动了：
在这里插入图片描述

2.基于链表的有界阻塞队列：

public static void main(String[] args) throws InterruptedException {
        //基于链表的有界阻塞队列，队列容量为10
        LinkedBlockingQueue queue = new LinkedBlockingQueue<Integer>(10);
        // 循环向队列添加元素
        for (int i = 0; i < 20; i++) {
            queue.put(i);
            System.out.println("向队列中添加值:" + i);
        }
    }

到了第10个就阻塞不动了：
在这里插入图片描述

3.基于链表的无界阻塞队列（上面的2不添加队列容量就是无界）：

public static void main(String[] args) throws InterruptedException {
        //基于链表的无界阻塞队列，队列容量为无限
        LinkedBlockingQueue queue = new LinkedBlockingQueue<Integer>();
        // 循环向队列添加元素
        for (int i = 0; i < 20; i++) {
            queue.put(i);
            System.out.println("向队列中添加值:" + i);
        }
    }

循环的所有数据都执行完成‘
在这里插入图片描述
4.同步移交阻塞队列

public static void main(String[] args) throws InterruptedException {
        //同步移交阻塞队列
        SynchronousQueue queue = new SynchronousQueue<Integer>();
        //插入值
        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();
    }

上面的插入值或者删除值缺少任何一个，都不会输出下面内容，会进入阻塞状态
在这里插入图片描述

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

1.AbortPolicy终止策略(默认)
2.DiscardPolicy抛弃策略
3.DiscardOldestPolicy抛弃旧任务策略
4.CallerRunsPolicy调用者运行策略

六.创建线程池的方法：

1.newCachedThreadPool在这里插入图片描述
2.newFixedThreadPool
在这里插入图片描述
3.newSingleThreadExecutor
在这里插入图片描述

七.向线程池提交任务：

7.1 submit

 @Test
    public void submitTest() throws ExecutionException, InterruptedException {
        // 创建线程池
        ExecutorService threadPool =Executors.newCachedThreadPool();

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

        //阻塞方法，直到任务有返回值后，才向下执行
        Integer num = future.get() ;
        
        System.out.println("执行结果:" + num);
    }

7.2 execute:

   @Test
    public void executeTest() throws InterruptedException {

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

        //利用execute方法提交任务，没有返回结果
        threadPool.execute(() -> {
            try {
                Thread.sleep(1000 * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Integer num = 2 * 5;
            System.out.println("执行结果:" + num);
        });

        Thread.sleep(1000L*1000);
    }

在这里插入图片描述

八.线程池的状态：

在这里插入图片描述

九.线程池的饱和策略：

9.1线程池饱和策略之终止策略：

package com.smart.agriculture;

import org.junit.After;
import org.junit.Test;

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

/**
 * 饱和策略
 */
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() +
                    "】正在执行【" + this.taskName + "】任务...");

            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("线程【" + Thread.currentThread().getName() +
                    "】已执行完【" + this.taskName + "】任务!!!");
        }


    }

    /**
     * 线程池的执行过程
     * 2个核心线程
     * 5个任务的队列
     * 3个最大线程:1个线程可用
     * <p>
     * 前2个任务，会占用2个核心线程
     * 第3个到第7个任务，会暂存到任务队列中
     * 第8个任务，会启动最大线程，去执行
     * 第9,10个任务，没有线程可以去执行 报红
     */
    @Test
    public void abortPolicyTest() {
        // 设置饱和策略为终止策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        for (int i = 1; i <= 10; i++) {
            try {
                //提交10个线程任务
                executor.execute(new Task("线程任务" + i));
            } catch (Exception e) {
                System.err.println(e);
            }
            // 关闭线程池
            executor.shutdown();
        }
    }

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

结果如下：
在这里插入图片描述
9.2 线程池之饱和策略之抛弃策略：

package com.smart.agriculture;

import org.junit.After;
import org.junit.Test;

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

/**
 * 抛弃策略
 */
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() +
                    "】正在执行【" + this.taskName + "】任务...");

            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("线程【" + Thread.currentThread().getName() +
                    "】已执行完【" + this.taskName + "】任务!!!");
        }


    }

    /**
     * 线程池的执行过程
     * 2个核心线程
     * 5个任务的队列
     * 3个最大线程:1个线程可用
     * <p>
     * 前2个任务，会占用2个核心线程
     * 第3个到第7个任务，会暂存到任务队列中
     * 第8个任务，会启动最大线程，去执行
     * 第9,10个任务，没有线程可以去执行 不会报红，直接被忽略
     * 
     */
    @Test
    public void abortPolicyTest() {
        //设置饱和策略为 抛弃策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 1; i <= 10; i++) {
            try {
                //提交10个线程任务
                executor.execute(new Task("线程任务" + i));
            } catch (Exception e) {
                System.err.println(e);
            }
            // 关闭线程池
            executor.shutdown();
        }
    }

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

在这里插入图片描述
9.3 线程池之饱和策略之抛弃旧任务策略：

package com.smart.agriculture;

import org.junit.After;
import org.junit.Test;

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

/**
 * 抛弃旧任务策略
 */
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() +
                    "】正在执行【" + this.taskName + "】任务...");

            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("线程【" + Thread.currentThread().getName() +
                    "】已执行完【" + this.taskName + "】任务!!!");
        }


    }

    /**
     * 线程池的执行过程
     * 2个核心线程
     * 5个任务的队列
     * 3个最大线程:1个线程可用
     * <p>
     * 前2个任务，会占用2个核心线程
     * 第3个到第7个任务，会暂存到任务队列中
     * 第8个任务，会启动最大线程，去执行
     * 第9,10个任务，没有线程可以去执行 第9个任务取代第3个任务，第10给任务取代第4个任务暂存在任务队列中，第3，4个任务会丢失，不会被执行
     */
    @Test
    public void abortPolicyTest() {
        //设置饱和策略为 抛弃旧任务策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 1; i <= 10; i++) {
            try {
                //提交10个线程任务
                executor.execute(new Task("线程任务" + i));
            } catch (Exception e) {
                System.err.println(e);
            }
            // 关闭线程池
            executor.shutdown();
        }
    }

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

在这里插入图片描述
9.4 线程池之饱和策略之调用者运行策略：

package com.smart.agriculture;

import org.junit.After;
import org.junit.Test;

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

/**
 * 调用者运行策略
 */
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() +
                    "】正在执行【" + this.taskName + "】任务...");

            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("线程【" + Thread.currentThread().getName() +
                    "】已执行完【" + this.taskName + "】任务!!!");
        }


    }

    /**
     * 线程池的执行过程
     * 2个核心线程
     * 5个任务的队列
     * 3个最大线程:1个线程可用
     * <p>
     * 前2个任务，会占用2个核心线程
     * 第3个到第7个任务，会暂存到任务队列中
     * 第8个任务，会启动最大线程，去执行
     * 第9没有线程可以去执行 调用者自己的主线程执行第9个任务
     * 到第10个线程，前2个任务执行完成，所以也开始执行第10个线程
     */
    @Test
    public void abortPolicyTest() {
        //设置饱和策略为 调用者运行策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 1; i <= 10; i++) {
            try {
                //提交10个线程任务
                executor.execute(new Task("线程任务" + i));
            } catch (Exception e) {
                System.err.println(e);
            }
            // 关闭线程池
            executor.shutdown();
        }
    }

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

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/8109.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

2003-2019年各省专利申请和授权量数据/2003-2019年31省专利申请和授权量数据

2003-2019年各省专利申请和授权量数据/2003-2019年31省专利申请和授权量数据

2003-2019年各省专利申请和授权量数据/2003-2019年31省专利申请量和授权量数据 2003-2019年各省专利申请和授权量数据/2003-2019年31省专利申请和授权量数据 1、时间&#xff1a;2003-2019年 2、来源&#xff1a;国家知识产权专利数据库 3、指标&#xff1a;专利申请数、发…
阅读更多...
数据结构和算法（一）：复杂度、数组、链表、栈、队列

数据结构和算法（一）：复杂度、数组、链表、栈、队列

从广义上来讲&#xff1a;数据结构就是一组数据的存储结构 &#xff0c; 算法就是操作数据的方法 数据结构是为算法服务的&#xff0c;算法是要作用在特定的数据结构上的。 10个最常用的数据结构&#xff1a;数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie树 10…
阅读更多...
办公协作效率想提质增效，可借助开源大数据工具！

办公协作效率想提质增效，可借助开源大数据工具！

在信息爆炸式发展的今天&#xff0c;提升办公协作效率&#xff0c;让各部门的信息有效互通起来&#xff0c;做好数据管理&#xff0c;已经成为众企业提升竞争力的方式方法。那么&#xff0c;如果想要提升办公效率&#xff0c;就需要了解开源大数据工具了。在数字化发展进程中&a…
阅读更多...
《扬帆优配》西藏地震！美史上最严排放新规将出台，美股收涨

《扬帆优配》西藏地震！美史上最严排放新规将出台，美股收涨

当地时间周四&#xff0c;美股遍及收高&#xff0c;科技股领涨。因耶稣受难日&#xff0c;美股4月7日&#xff08;周五&#xff09;休市&#xff0c;周四为美股本周最终一个买卖日&#xff0c;从本周状况来看&#xff0c;纳指与标普500指数均录得跌幅&#xff0c;别离跌1.1%和0…
阅读更多...
回归预测 | MATLAB实现PSO-RF粒子群算法优化随机森林多输入单输出回归预测

回归预测 | MATLAB实现PSO-RF粒子群算法优化随机森林多输入单输出回归预测

回归预测 | MATLAB实现PSO-RF粒子群算法优化随机森林多输入单输出回归预测 目录回归预测 | MATLAB实现PSO-RF粒子群算法优化随机森林多输入单输出回归预测效果一览基本介绍程序设计参考资料效果一览 基本介绍 MATLAB实现PSO-RF粒子群算法优化随机森林多输入单输出回归预测 粒子…
阅读更多...
第十四届蓝桥杯题解

第十四届蓝桥杯题解

声明&#xff1a;以下都无法确定代码的正确性&#xff0c;是赛时代码&#xff0c;希望大家见谅&#xff01;思路可以参考&#xff0c;等后续可以评测之后再去修改博客内错误&#xff0c;也希望大家能够指正错误&#xff01; 试题A&#xff1a;日期统计 分析&#xff1a;这道题…
阅读更多...
45-Dockerfile-ARG/ENV指令

45-Dockerfile-ARG/ENV指令

AGR/ENV指令前言ARG作用格式说明生效范围使用示例ENV作用格式说明使用环境变量使用示例ARG 和 ENV 的区别前言 本篇来学习下Dockerfile中的AGR/ENV指令 ARG 作用 定义一个可以在构建镜像时使用的变量 格式 ARG <name>[<default value>]说明 在执行 docker b…
阅读更多...
【数据结构】AVL树

【数据结构】AVL树

&#x1f431;作者&#xff1a;一只大喵咪1201 &#x1f431;专栏&#xff1a;《数据结构与算法》 &#x1f525;格言&#xff1a;你只管努力&#xff0c;剩下的交给时间&#xff01; AVL树&#x1f332;AVL树&#x1f334;AVL树的插入&#x1f334;AVL树的旋转左单旋右单旋左…
阅读更多...
Springboot基础学习之(十三)：通过代码实现对数据库的增删该查操作（数据库：mysql)

Springboot基础学习之(十三)：通过代码实现对数据库的增删该查操作（数据库：mysql)

Springboot这个系列实现的案例&#xff1a;员工后台管理系统 之前讲解的内容是前后端的交互&#xff0c;并没有涉及到数据库。把员工信息放置在一个数组中&#xff0c;实现的方法则是对数组的增删改查操作&#xff0c;但是从今天开始&#xff0c;实现的功能则是在数据库的基础上…
阅读更多...
看完这篇 教你玩转渗透测试靶机vulnhub——My File Server: 2

看完这篇 教你玩转渗透测试靶机vulnhub——My File Server: 2

Vulnhub靶机My File Server: 2渗透测试详解Vulnhub靶机介绍&#xff1a;Vulnhub靶机下载&#xff1a;Vulnhub靶机安装&#xff1a;Vulnhub靶机漏洞详解&#xff1a;①&#xff1a;信息收集&#xff1a;②&#xff1a;FTP匿名登入③&#xff1a;SSH私钥登入④&#xff1a;SMB共享…
阅读更多...
Mysql一条多表关联SQL把CPU打爆了，如何优化

Mysql一条多表关联SQL把CPU打爆了，如何优化

今天是清明假期的第三天&#xff0c;收到同事的求助&#xff0c;DB的CPU被打爆了&#xff01; 查看监控&#xff0c;CPU已经被打爆100% 登录mysql&#xff0c;DB无锁阻塞&#xff0c;元凶是一个异常sql,存在39个并发执行。 SQL的明细如下&#xff1a; select TEMPSALE.USER_ID…
阅读更多...
ChatGPT 被大面积封号，到底发生什么了？

ChatGPT 被大面积封号，到底发生什么了？

意大利数据保护机表示 OpenAI 公司不但非法收集大量意大利用户个人数据&#xff0c;没有设立检查 ChatGPT 用户年龄的机制。 ChatGPT 似乎正在遭遇一场滑铁卢。 3月31日&#xff0c; 大量用户在社交平台吐槽&#xff0c;自己花钱开通的 ChatGPT 账户已经无法登录&#xff0c;更…
阅读更多...
港科夜闻｜香港科大(广州)熊辉教授获委任为协理副校长(知识转移)

港科夜闻｜香港科大(广州)熊辉教授获委任为协理副校长(知识转移)

关注并星标每周阅读港科夜闻建立新视野 开启新思维1、香港科大(广州)熊辉教授获委任为协理副校长(知识转移)。在任期间&#xff0c;熊教授将为香港科大知识转移战略发展提供全面领导&#xff0c;鼓励和促进教师、学生和校友之间的知识转移&#xff0c;促进创业发展、技术研究及…
阅读更多...
数据仓库、数据集市、数据湖，你的企业更适合哪种数据管理架构？

数据仓库、数据集市、数据湖，你的企业更适合哪种数据管理架构？

建设企业级数据平台&#xff0c;首先需要了解企业数据&#xff0c;确认管理需求&#xff0c;并选择一个数据管理架构。那么面对纷繁复杂的数据来源&#xff0c;多元化的数据结构&#xff0c;以及他们的管理使用需求&#xff0c;企业数据平台建设该从何处入手呢&#xff1f;哪个…
阅读更多...
机器学习笔记之正则化(二)权重衰减角度(直观现象)

机器学习笔记之正则化(二)权重衰减角度(直观现象)

机器学习笔记之正则化——权重衰减角度[直观现象]引言回顾&#xff1a;拉格朗日乘数法角度观察正则化过拟合的原因&#xff1a;模型参数的不确定性正则化约束权重的取值范围L1L_1L1​正则化稀疏权重特征的过程权重衰减角度观察正则化场景构建权重衰减的描述过程权重衰减与过拟合…
阅读更多...
ChatGPT常用prompts汇总

ChatGPT常用prompts汇总

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️&#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…
阅读更多...
一个开源人的心酸哭诉

一个开源人的心酸哭诉

编者按&#xff1a;这篇文章比较长&#xff0c;但值得一读。从这篇文章&#xff0c;你可以看到一些开源开发者的内心活动&#xff0c;看看他们的热情、抱负、无奈、心酸、愤怒、失望和痛斥&#xff1b;看看他们如何指责、讽刺、乞求、羞辱那些使用他们作品而无视他们痛苦的人&a…
阅读更多...
Java 泛型 使用案例

Java 泛型 使用案例

参考资料 Java 基础 - 泛型机制详解路人甲-Java泛型专题 目录一. 通用Mapper1.1 实体类1.2 Mapper基类1.3 自定义接口1.4 抽象基类Service1.5 调用二. session和bean的获取一. 通用Mapper 1.1 实体类 ⏹ Accessors(chain true): 允许链式调用 import lombok.Data; import …
阅读更多...
Python 进阶指南（编程轻松进阶）：五、发现代码异味

Python 进阶指南（编程轻松进阶）：五、发现代码异味

原文&#xff1a;http://inventwithpython.com/beyond/chapter5.html 导致程序崩溃的代码显然是错误的&#xff0c;但是崩溃并不是发现程序问题的唯一手段。其他迹象可能表明程序存在更微妙的错误或不可读的代码。就像气体的味道可以指示气体泄漏或者烟雾的味道可以指示火灾一样…
阅读更多...
[国产化]arm架构的服务器虚拟机软件---Qemu虚拟机

[国产化]arm架构的服务器虚拟机软件---Qemu虚拟机

项目场景&#xff1a; 架构&#xff1a;arm 服务器型号&#xff1a;昆泰r522 操作系统&#xff1a;欧拉22.3arm 问题描述 对应需要有arm架构的虚拟机&#xff0c;vmware没有arm版本。寻找替代品。 之前有人介绍可以用zstack。但是需要改变操作系统。所以就放弃了。选择了&…
阅读更多...
最新文章

Copyright @ 2022~2023