[Java EE] 多线程(六):线程池与定时器

news2024/12/25 14:24:09

1. 线程池

1.1 什么是线程池

我们前面提到,线程的创建要比进程开销小,但是如果线程的创建/销毁比较频繁,开销也会比较大.所以我们便引入了线程池,线程池的作用就是提前把线程都创建好,放到用户态代码中写的数据结构中,后面就可以随用随取.
线程池最大的好处就是减少每次启动,销毁线程的开销.线程的创建和销毁,需要通过用户态+内核态来配合完成,但是线程池只需要通过用户态即可完成,不需要内核态的配合.
在这里插入图片描述
在这里插入图片描述

举例说明:渣女小故事
有一位小姐姐是个渣女,创建和销毁线程就像一位小姐姐和他的男朋友分手了,再和下一位男朋友一点一点培养感情,而线程池就相当于,小姐姐有一个备胎池,他同时和好几个小哥哥培养感情,如果和其中一个分手了,就可以从备胎池中调用其他小哥哥,无缝衔接.
在这里插入图片描述

1.2 线程池的构造方法参数解释(面试常考)

线程池的类名是TreadPoolExecutor,其中他的构造方法中提供了丰富的参数类型,我们下面来一一解释一下这些参数:

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
  1. corePoolSize:线程池中的核心线程数.
  2. maximumPoolSize:线程池中的最大线程数.等于核心线程数+非核心线程数,其中非核心线程数是根据当前任务的多少来动态管理的.(至于最大线程要设置为多少,这个没有一个固定的值,一般认为,和CPU的逻辑核心数有关,可能是n+1,2n等)
  3. keepAliveTime: 允许非核心线程数的最大空闲时间.超出最大空闲时间,就会被回收.
  4. unit:等待时间的时间单位,时,分,秒.
  5. workQueue:用于存放任务的阻塞队列.后续线程池内部的工作线程就会消费这个队列,从而完成任务的执行.
  6. threadFactory:线程创建工厂,参与具体的线程创建工作.通过不同的工厂创建出的不同线程相当于对一些属性进行了不同的初始化设置.
    针对线程工厂,我们又可以引出另一个话题:工厂设计模式.
    这种设计模式主要是针对解决构造方法的不足而创建出的一种设计模式.
    比如,我们给出了一个点(Point)类:
    我们知道,一个点想要表示出来,一种是通过笛卡尔坐标系表示,一种是通过极坐标的方式来表示,但是我们会发现,笛卡尔坐标系的参数和极坐标系的参数个数相同,而且它们的参数类型也相同,这就使得我们不可以用构造方法来构造这个点.
public class Point {
    public double x = 0;
    public double y = 0;
    public double r = 0;
    public double a = 0;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public Point(double r,double a){
        this.a = a;
        this.r = r;
    }
}

编译报错:
在这里插入图片描述
所以我们便引入了工厂设计模式来解决这个问题:
我们引入PointBuilder这个类,通过PointBuilder来构造这个点,并在Point这个点中设置set方法.

class Point {
    private double x = 0;
    private double y = 0;
    private double r = 0;
    private double a = 0;

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void setR(double r) {
        this.r = r;
    }

    public void setA(double a) {
        this.a = a;
    }
}
class PointBuilder{
    public static Point pointXY(double x,double y){
        Point p = new Point();
        p.setX(x);
        p.setY(y);
        return p;
    }
    public static Point pointRA(double r,double a){
        Point p = new Point();
        p.setA(a);
        p.setR(r);
        return p;
    }
}
  1. handler:任务超出线程池的承受范围的拒绝策略
    • AbortPolicy():超过负荷,直接抛出异常.
    • CallerRunsPolicy():调用者负责处理多出来的任务.
    • DiscardOldestPolicy():丢弃队列中最老的任务.
    • DiscardPolicy():丢弃新来的任务.

举例说明:年会不能停
有请老朋友:马杰克,潘妮,杰弗瑞,胡建林
corePoolSize:相当于公司中的正式员工,比如马杰克,杰弗瑞,胡建林.
maximumPoolSize:相当于公司中的所有员工,包括正式员工+外包.
keepAliveTime:允许外包员工的最大空闲时间,比如允许潘妮的最大空闲时间,一旦超过最大空闲时间,杰弗瑞就会把潘妮开除掉.
unit:允许潘妮的空闲时间单位,时,分,秒.
workQueue:每次员工们领取工作任务的账号.
threadFactory:公司不同的HR,通过HR招人(创建线程)
handler:员工们任务太多时候的拒绝策略
比如有一天杰弗瑞需要和胡建林要去干一场直播,但是胡建林由于工作太多,它需要拒绝杰弗瑞,其中胡建林有多种拒绝他的策略.第一种方法就是:胡建林直接罢工,工作和直播都不干了,就是直接罢工了.(AbortPolicy()).第二种方法就是:胡建林让杰弗瑞自己去直播(CallerRunsPolicy()).第三种方法就是:胡建林可以先放下手头的工作,和杰弗瑞去直播(DiscardOldestPolicy()).第四种方法就是:胡建林可以先完成自己的工作,之后在去和杰弗瑞直播(DiscardPolicy())
在这里插入图片描述

1.3 标准库中的线程池

Java源码的编写者也知道,上面这个方法用起来特别难,因为有许多参数.所以Java的标准库中提供了创建线程的一个工厂类Executors(本质上是Executor的封装),其中有一些创建线程的方法.这些方法的返回值可以直接当做线程池来使用,返回值的类型为ExecutorService.

  • 线程池中的核心方法为submit,它是为线程池的阻塞队列中添加Runnable对象.
  • 创建线程的工厂类Executor中右许多创建线程的方法,不同方法返回的线程属性各不相同.
    • newFixedTreadPool(int nTread):创建固定线程数的线程池
    • newCachedTreadPool():创建线程数目动态变化的线程池.(随任务数量变化)
    • newSingleTreadExectuor():创建单线程的线程池.
    • newScheduleTreadPool():设定延迟时间后执行指令,或者定期执行指令,是进阶版的Timer.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo24 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        //固定创建10个线程,注意返回类型
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("tread"+ finalI + Thread.currentThread().getName());
                }//只有固定的10个线程在执行这100个任务
            });
        }
        ExecutorService service1 = Executors.newCachedThreadPool();
        //随着任务的增多,线程创建增多
        for (int i = 0; i < 100; i++) {
            int finalI = i;
            service1.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("tread"+ finalI + Thread.currentThread().getName());
                }
            });
        }
    }
}

创建固定线程线程池的运行结果:
在这里插入图片描述
我们看到,submit方法提供了100个任务,但是执行这100个任务的只有10个线程在执行.

下面是创建一个现场数量动态变化的线程池:
在这里插入图片描述
我们看到,线程池中被创建出了很多线程,100个任务由很多线程来执行.

1.4 实现线程池

  • 首先我们要实现核心方法submit,将任务添加到线程池的队列中.
  • 使用Worker类描述一个工作线程.使用Runnable描述一个任务.
  • 使用BlockingQueue组织所有的任务.
  • 每个Worker线程需要做的事情就是不断从BlockingQueue中获取任务并执行.
  • 指定线程池的最大线程数.
  • submit方法时生产者,不断往队列中添加Runnable元素,而构造方法是消费者,不停地从队列中获取Runnable元素并执行.
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 创建固定线程的线程池
 */
public class MyTreadPool {
    public BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
    //通过阻塞队列来保存可运行对象
    //向阻塞队列提交任务,生产者
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
    //构造方法创建线程来执行队列中的任务.消费者
    public MyTreadPool(int nTread) {
        for (int i = 0; i < nTread; i++) {
            Thread thread = new Thread(()->{
                while (true){//每个线程不停地从队列中取出元素
                    try {
                        queue.take().run();//获取任务清单
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            thread.start();//创建完线程之后立即启动
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyTreadPool myTreadPool = new MyTreadPool(10);
        for (int i = 0; i < 1000; i++) {
            int finalI = i;
            myTreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("Tread"+ finalI + Thread.currentThread().getName());
                }
            });
        }

    }
}

运行结果:
在这里插入图片描述

2. 定时器

2.1 概念

指定一个任务(Runnable),并且指定一个时间,此时这个任务不会立即执行,而是在时间到达之后再执行.
在这里插入图片描述
定时器在我们日常的开发中也非常常见.比如在双11,0点开始定时抢购,再比如如果网络超过5000ms无响应的时候,就会尝试重新连接等.

2.2 标准库中的定时器

  • 标准库中提供一个Timer类.Timer的核心方法为schedule,为Timer的队列中添加元素.
  • schedule包含两个参数,第一个参数指定将要执行的任务代码,第二个参数指定多长时间执行.
import java.util.Timer;
import java.util.TimerTask;

public class Demo25 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        },3000);//延迟3s后再执行
    }
}

2.3 定时器的模拟实现

  • 队列中使用优先级队列实现,把时间作为优先级队列的比较规则,delay时间短的放在堆顶.(注意不要使用PriorityBlockingQueue,容易死锁)
  • 队列中的每一个元素是一个Task对象.
  • Task中带有一个时间属性.
  • 同时有一个Worker线程一直扫描队首元素,通过与当前系统的时间戳去比较,看队首元素是否到达执行时间.
  • 其次,由于我们使用的是优先级队列,其中一定存在线程安全问题,我们需要使用synchronized对其进行加锁.
import java.util.PriorityQueue;

/**
 * 描述一个任务类
 */
class TimerTask implements Comparable<TimerTask>{
    public Runnable runnable;
    public long time;

    public TimerTask(Runnable runnable, int delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis()+delay;
    }

    @Override
    public int compareTo(TimerTask o) {
        return (int)(this.time-o.time);//这里谁减谁不要记,试一试就知道了
    }
}
/**
 * 定时器
 */
public class MyTimer {
    public PriorityQueue<TimerTask> priorityQueue = new PriorityQueue<>();

    /**
     * 该方法为优先级队列提供任务,生产者
     * @param runnable 可运行对象
     * @param delay 延时时间
     */
    public void schedule(Runnable runnable,int delay){
        synchronized (this){//添加元素时加锁
            priorityQueue.offer(new TimerTask(runnable,delay));
            this.notify();//唤醒构造方法的wait
        }
    }

    /**
     * 创建线程执行队列中的任务,消费者
     */
    public MyTimer() {
        Thread thread = new Thread(()->{
            while (true){//循环扫描堆顶元素,判断是否要执行
                synchronized (this){//由于优先级队列的不安全性,所以加锁
                    if (priorityQueue.isEmpty()){
                        try {
                            this.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    long cur = System.currentTimeMillis();//注意保存当前时间,不可以写在判断时间中
                    //否则每次都在改变
                    TimerTask task = priorityQueue.peek();
                    if (cur >= task.time){
                        priorityQueue.poll().runnable.run();
                    }else {
                        try {
                            this.wait(task.time-cur);//注意等待时间是任务时间减去当前是时间
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        thread.start();//注意启动线程
    }
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        },2000);
    }
}

注意事项:

  • 不可以把wait()那一行使用continue代替,否者就会出现"忙等"的状态.
  • wait()处不可以用sleep()代替,否者就把锁抱死了,应该在休眠的时候让其他线程继续调度系统资源.

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Python中动画显示与gif生成

1. 动画生成 主要使用的是 matplotlib.animation &#xff0c;具体示例如下&#xff1a; import matplotlib.pyplot as plt import matplotlib.animation as animation import numpy as np fig, ax plt.subplots() t np.linspace(0, 3, 40) g -9.81 v0 12 z g * t**2 / …

【Python函数和类6/6】类与对象

目录 目标 类与对象 类的定义 栗子 实例化对象 属性和方法的调用 特殊的self参数 类方法的其它参数 函数与方法的区别 总结 目标 在前面的博客当中&#xff0c;我们已经接触了一部分封装。比如&#xff1a;将数据扔进列表中&#xff0c;这就是一个简单…

短视频素材去哪里搬运?短视频素材有哪些类型?

在这个数字化和视觉传达至关重要的时代&#xff0c;选择合适的视频素材对于提升视频内容的吸引力和观众参与度至关重要。无论您是一名广告制片人、社交媒体经理还是独立视频制作者&#xff0c;以下这些精选的视频素材网站将为您提供从高清视频到特效资源的全面支持&#xff0c;…

工厂模式和策略模式区别

工厂模式和策略模式都是面向对象设计模式&#xff0c;但它们的目的和应用场景有所不同。 工厂模式是一种创建型设计模式&#xff0c;旨在通过使用一个工厂类来创建对象&#xff0c;而不是直接使用new关键字来创建对象。这样做可以使系统更容易扩展和维护&#xff0c;因为新的对…

reactjs后台管理系统搭建

1 通过yarn 模板创建reactjs项目 yarn create vite reactjs-antdesign-admin --template react-ts 2 基础路由测试 定义一个router/index.tsx&#xff0c;里面定义路由组件 const Router: React.FC () > {return (<HashRouter><Switch><Route path"…

Edge浏览器使用心得与深度探索

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…

信息时代的智慧导航:高效搜索、信息筛选与信任构建的全面指南!

文章目录 一、高效搜索&#xff1a;快速定位目标信息的秘诀二、信息筛选&#xff1a;去伪存真&#xff0c;找到有价值的信息三、信任构建&#xff1a;深入了解与直接沟通《搜索之道&#xff1a;信息素养与终身学习的新引擎》亮点内容简介目录获取方式 随着科技的飞速发展&#…

前端基础学习html(2)

目录 表格标签&#xff1a; 列表标签&#xff1a; 表格标签&#xff1a; <!-- 表格基本架构 --><!-- tr表示一行&#xff0c;td表示一行内单元格 --><!--th为第一行表头加粗居中显示 --><table border"1"><thead><tr><th&g…

用Stream流方式合并两个list集合(部分对象属性重合)

一、合并出共有部分 package com.xu.demo.test;import java.util.Arrays; import java.util.List; import java.util.stream.Collectors;public class ListMergeTest1 {public static void main(String[] args) {List<User> list1 Arrays.asList(new User(1, "Alic…

【linux学习指南】linux指令与实践文件编写

文章目录 &#x1f4dd;前言&#x1f320; linux目录结构&#x1f309;linux命令介绍 &#x1f320;pwd命令&#x1f309;mkdir指令&#xff08;重要&#xff09; &#x1f320;cd 指令&#x1f309;touch指令 &#x1f320;rmdir指令 && rm 指令&#xff08;重要&…

nginx--配置文件

组成 主配置文件&#xff1a;nginx.conf 子配置文件&#xff1a;include conf.d/*.conf 协议相关的配置文件&#xff1a;fastcgi uwsgi scgi等 mime.types&#xff1a;⽀持的mime类型&#xff0c;MIME(Multipurpose Internet Mail Extensions)多用途互联⽹网邮件扩展类型&…

KUKA机器人KR3 R540维护保养——涂润滑脂

KUKA机器人在保养时少不了润滑脂&#xff0c;不同型号的机器人需要的润滑脂类型也不一样&#xff0c;保养时注意选用合适的润滑脂。本篇文章以KUKA机器人KR3 R540为例&#xff0c;在轴盖板 A2、A3、A5 的内侧涂上润滑脂。 一、涂润滑脂的作用 拆开机器人一个轴的盖板&am…

链表面试题2

1&#xff0c;合并两个有序链表 我们先定义一个虚拟节点newH&#xff0c; 然后按照上图所走&#xff0c;但是当其中一个链表走空时&#xff0c;我们只需返回另一个链表即可 class Solution {public ListNode mergeTwoLists(ListNode headA, ListNode headB) {ListNode newhead…

python基础语法--函数

一、函数概述 函数就是执行特定任务完成特定功能的一段代码。可以在程序中将某一段代码定义成函数&#xff0c;并指定一个函数名和接收的输入&#xff08;参数&#xff09;&#xff0c;这样就可以在程序的其他地方通过函数名多次调用并执行该段代码了。 每次调用执行后&#…

Mybatis-Plus学习:快速入门、核心功能、扩展功能、插件功能

文章目录 MybatisPlus快速入门快速开始常见注解常见配置 核心功能条件构造器&#xff08;Wrapper&#xff09;自定义SQLService接口基本用法基础业务接口复杂业务接口Lamda查询Lamda更新批量新增 扩展功能代码生成代码生成器快速开发插件 静态工具逻辑删除枚举处理器JSON处理器…

机器人系统ros2-开发实践04-ROS 2 启动文件管理大型项目的最佳实践

机器人上的大型应用通常涉及多个互连的节点&#xff0c;每个节点可以有许多参数。海龟模拟器中模拟多只海龟就是一个很好的例子。海龟模拟由多个海龟节点、世界配置以及 TF 广播器和监听器节点组成。在所有节点之间&#xff0c;存在大量影响这些节点的行为和外观的 ROS 参数。 …

【C++】哈希的应用---位图

目录 1、引入 2、位图的概念 3、位图的实现 ①框架的搭建 ②设置存在 ③设置不存在 ④检查存在 ​4、位图计算出现的次数 5、完整代码 1、引入 我们可以看一道面试题 给40亿个不重复的无符号整数&#xff0c;没排过序。给一个无符号整数&#xff0c;如何快速判断一个数…

罗宾斯《管理学》第15版笔记/课后习题/考研真题答案

第Ⅰ篇 管理导论 第1章 工作场所中的管理者和你 1.1 知识结构导图 1.2 考点难点归纳 1.3 课后习题详解 1.4 考研真题详解 附加模块一 管理史 知识结构导图 考点难点归纳 课后习题详解 考研真题详解 第2章 决 策 2.1 知识结构导图 2.2 考点难点归纳 2.3 课后习题详解…

C++string类使用大全

目录 温馨提示&#xff1a;这篇文章有约两万字 什么是string类&#xff1f; 一. 定义和初始化string对象 1.string的构造函数的形式&#xff1a; 2.拷贝赋值运算符 3.assign函数 二.string对象上的操作 1.读写string对象 2.读取未知数量的string对象 3.使用getline …

STM32中断系统详解

系列文章目录 STM32单片机系列专栏 C语言术语和结构总结专栏 文章目录 1. 中断基本概念 2. STM32中断 3. NVIC的基本组件 3.1 NVIC的基本组件 3.2 NVIC的优先级 4. EXTI外部中断 4.1 基本概念 4.2 基本结构 5. AFIO 1. 中断基本概念 中断&#xff08;Interrupt&…