【多线程】定时器和线程池

请添加图片描述

✨个人主页:bit me👇
✨当前专栏:Java EE初阶👇
✨每日一语:种一棵树最好的时间是十年前,其次是现在。

目 录

  • ⌚️一. 定时器
    • 📄1. 定时器是什么
    • 📃2. 标准库中的定时器
    • 📑3. 实现定时器
  • ⏰二. 线程池
    • 📕1. 标准库中的线程池
    • 📘2. 实现线程池:

⌚️一. 定时器


📄1. 定时器是什么

定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码。

定时器是一种实际开发中非常常用的组件,在标准库中也有也有
 
比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连.
比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除).
类似于这样的场景就需要用到定时器.


📃2. 标准库中的定时器

  • 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .
  • schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒).
public class Demo22 {
    public static void main(String[] args) throws InterruptedException {
        // java.util 里的一个组件
        Timer timer = new Timer();
        //schedule 这个方法的效果是 "安排一个任务"
        //不是立刻执行,而是 3000 ms 之后再执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("这是一个要执行的任务:");
            }
        },3000);

        while (true){
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

在这里插入图片描述

注意:

  • 程序没有结束是因为:实现定时器,背后涉及到多线程,Timer 里面有线程,这个线程的运行阻止了进程的退出!
  • sleep 和定时器的区别:使用 sleep 是把当前线程给阻塞了,sleep 的时间里,啥也做不了,只能等待,但是使用定时器,之前的线程该干什么干什么。

📑3. 实现定时器

  • 一个带优先级的阻塞队列

为啥要带优先级呢?
 
因为阻塞队列中的任务都有各自的执行时刻 (delay). 最先执行的任务一定是 delay 最小的. 使用带优先级的队列就可以高效的把这个 delay 最小的任务找出来.

  • 队列中的每个元素是一个 MyTask 对象.
  • MyTask 中带有一个时间属性, 队首元素就是即将执行的任务
  • 同时有一个线程一直扫描队首元素, 看队首元素是否需要执行
  1. MyTimer 类提供的核心接口为 schedule, 用于注册一个任务, 并指定这个任务多长时间后执行.
class MyTimer {
    public void schedule(Runnable command, long after) {
 		// TODO
    }
}
  1. MyTask 类用于描述一个任务(作为 MyTimer 的内部类). 里面包含一个 Runnable 对象和一个 time(毫秒时间戳)(这个对象需要放到 优先队列 中. 因此需要实现 Comparable 接口)
class MyTask implements Comparable<MyTask> {
    private Runnable command;
    private long time;
    public MyTask(Runnable command,long after){
        this.command = command;
        this.time = System.currentTimeMillis() + after;
    }
    
    public void run(){
        command.run();
    }

    public long getTime(){
        return time;
    }

    public int compareTo(MyTask o){
        return (int) (this.time - o.time);
    }
}
  • System.currentTimeMillis() + after;是一个绝对的时间戳,不是 "多长时间之后能执行"
  • 重写 compareTo 方法要强制类型转换
  1. MyTimer 实例中, 通过 PriorityBlockingQueue 来组织若干个 MyTask 对象.
    通过 schedule 来往队列中插入一个个 MyTask 对象.
class MyTimer {
	private Object locker = new Object();
    // 核心结构
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue();
    
    public void schedule(Runnable command, long after) {
        	MyTask myTask = new MyTask(command,after);
        	queue.put(task);
        	
			synchronized (locker) {
            queue.put(myTask);
            locker.notify();
        }
   }    
}
  • 使用优先级队列来保存若干个任务,这个队列,会被多个线程同时访问
  1. schedule 可能是在多线程中被调用,每次调用都要往队列里添加元素
  2. 内部还需要有专门的线程来执行队列里的任务
  1. MyTimer 类中存在一个线程, 一直不停的扫描队首元素, 看看是否能执行这个任务.(“能执行” 指的是该任务设定的时间已经到达了)
class Timer {
 // ... 前面的代码不变
	public MyTimer(){
        //在这里启动一个线程
        Thread t = new Thread(()->{
           while (true){
               //循环过程中,就不断尝试从队列中获取到队首元素
               //判定队首元素当前的时间是否就绪,如果就绪了就执行,不就绪就不执行
               try {
                   synchronized (locker) {
                       MyTask myTask = queue.take();
                       long curTime = System.currentTimeMillis();
                       if (myTask.getTime() > curTime) {
                           //时间还没到,赛回到队列中
                           queue.put(myTask);
                           locker.wait(myTask.getTime() - curTime);
                       } else {
                           //时间到了,直接执行任务
                           myTask.run();
                       }
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }
}
  • MyTask myTask = queue.take(); 如果队列为空,就在这块阻塞;如果队列不为空:1.取出任务 -> 2.比较时间 -> 3.如果时间未到,插入任务回队列;紧接着继续执行上述操作。
  • 在短时间内产生大量循环,CPU 空转,没有实质性的执行任务,相当于 "忙等",因此在此处需要让线程休眠直到任务执行,如果此处用 sleep 来,是行不通的,sleep 休眠的时候无法打断,而 wait 也可以休眠线程而且还能用 notify 来唤醒。
  • 防范 put 和 wait 之间进行的时候出现新插入的元素要比最早的任务还早,就需要用锁把整体锁住一次执行完毕,就能有效避免出现问题。

附上总的实现代码

import java.sql.Time;
import java.util.PriorityQueue;
import java.util.concurrent.PriorityBlockingQueue;

//通过这个类来描述一个任务
class MyTask implements Comparable<MyTask> {
    //任务要干嘛
    private Runnable command;
    //任务啥时候干
    private long time;

    public MyTask(Runnable command,long after){
        this.command = command;
        //此处记录的时间是一个绝对的时间戳,不是 "多长时间之后能执行"
        this.time = System.currentTimeMillis() + after;
    }

    //执行任务的方法,直接在内部调用 Runnable 的 run 即可
    public void run(){
        command.run();
    }

    public long getTime(){
        return time;
    }

    public int compareTo(MyTask o){
        //希望时间小的在前面,时间大的在后面
        //谁减谁才能达到时间小的在前面,不用刻意背
        return (int) (this.time - o.time);
    }
}

//自己创建的定时器类
class MyTimer{
    //这是用来阻塞等待的锁对象
    private Object locker = new Object();

    //使用优先级队列来保存若干个任务
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

    //command 要执行的任务是啥
    //after 多长时间之后来执行这个任务
    public void schedule(Runnable command, long after){
        MyTask myTask = new MyTask(command,after);
        queue.put(myTask);

        synchronized (locker) {
            queue.put(myTask);
            locker.notify();
        }
    }

    public MyTimer(){
        //在这里启动一个线程
        Thread t = new Thread(()->{
           while (true){
               //循环过程中,就不断尝试从队列中获取到队首元素
               //判定队首元素当前的时间是否就绪,如果就绪了就执行,不就绪就不执行
               try {
                   synchronized (locker) {
                       MyTask myTask = queue.take();
                       long curTime = System.currentTimeMillis();
                       if (myTask.getTime() > curTime) {
                           //时间还没到,赛回到队列中
                           queue.put(myTask);
                           locker.wait(myTask.getTime() - curTime);
                       } else {
                           //时间到了,直接执行任务
                           myTask.run();
                       }
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }
}


public class Demo23 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();

        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("3333");
            }
        },6000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("2222");
            }
        },4000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("1111");
            }
        },2000);
    }
}

⏰二. 线程池

由于进程太重量,创建和销毁成本都比较高(需要申请释放资源),线程就是针对上述问题进行的优化(共用同一组系统资源),虽然如此,但是在频繁的创建和释放的情况下,线程也扛不住,于是进一步的优化出现了。

  • 线程池
  • 协程(纤程),轻量级线程

线程池解决问题的思路,就是把线程创建好了之后,放到池子里,需要使用线程,就直接从池子里取,而不是通过系统来创建,当线程用完了,也是还到池子里,而不是通过系统来销毁。

为什么把线程放到池子里就要比从系统这里创建线程来的快呢?
 
从池子里取,纯用户态操作。通过系统来创建,涉及到内核态操作。


📕1. 标准库中的线程池

ExecutorService threadPool = Executors.newFixedThreadPool(10);
  • ExecutorService 执行器,执行 Service 服务
  • Fixed 表示 “固定”
  • Executors 是一个类,newFixedThreadPool 是它的静态方法,借助静态方法,来创建实例,像这样的方法,称为 “工厂方法”,对应的设计模式,就叫做 “工厂模式”(由于构造方法的限制是要求名字和类名一样,实现重载又要求参数类型和个数不一样,所以此时只能通过工厂模式来实现类名不一样,参数类型和个数完全一样)
  • 使用 Executors.newFixedThreadPool(10) 能创建出固定包含 10 个线程的线程池.
  • 返回值类型为 ExecutorService
  • 通过 ExecutorService.submit 可以注册一个任务到线程池中.
public class Demo24 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);//固定线程池里的线程数量
        //Executors.newCachedThreadPool();//逐渐增加的线程池里的线程数量

        //把任务加载到线程池,用线程池里的线程完成任务
        for (int i = 0; i < 100; i++) {
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }

    }
}

Executors 创建线程池的几种方式:

  • newFixedThreadPool: 创建固定线程数的线程池
  • newCachedThreadPool: 创建线程数目动态增长的线程池.
  • newSingleThreadExecutor: 创建只包含单个线程的线程池.
  • newScheduledThreadPool: 设定 延迟时间后执行命令,或者定期执行命令. 是进阶版的 Timer.

Executors 本质上是 ThreadPoolExecutor 类的封装.

ThreadPoolExecutor 提供了更多的可选参数, 可以进一步细化线程池行为的设定. (后面详解)


📘2. 实现线程池:

  • 核心操作为 submit, 将任务加入线程池中
  • 使用类描述一个工作线程. 使用 Runnable 描述一个任务.
  • 使用一个 BlockingQueue 组织所有的任务
  • 每个线程要做的事情: 不停的从 BlockingQueue 中取任务并执行.
class MyThreadPool {
    //这个队列就是 "任务队列" 把当前线程池要完成的任务都放到这个队列中
    //再由线程池内部的工作线程负责完成他们
    private BlockingDeque<Runnable> queue = new LinkedBlockingDeque<>();

    //核心方法:往线程池里插入任务
    public void submit(Runnable runnable){
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //设定线程池里有几个线程
    public MyThreadPool(int n){
        //构造方法中,就需要创建一些线程,让这些线程负责完成上述执行任务的过程
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
               while (!Thread.currentThread().isInterrupted()){//1.判断标志类  2.判断线程有没有中断,中断了就不继续走
                   try {
                       Runnable runnable = queue.take();
                       runnable.run();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            });
            t.start();
        }
    }
}

public class Demo25 {
    public static void main(String[] args) {
        MyThreadPool myThreadPool = new MyThreadPool(10);
        for (int i = 0; i < 100; i++) {
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }
    }
}

!Thread.currentThread().isInterrupted() :1.判断标志类 2.判断线程有没有中断,中断了就不继续走

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

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

相关文章

【C语言初阶】初识C语言 | C语言知识预览

文章目录&#x1f490;专栏导读&#x1f490;文章导读&#x1f337;什么是C语言&#xff1f;&#x1f337;第一个C语言程序&#x1f337;数据类型&#x1f337;变量、常量、字符串&#x1f33a;定义变量的方法&#x1f33a;变量的分类&#x1f33a;变量的使用&#x1f33a;变量…

DJ2-5 DNS:Internet 的目录服务

目录 1. DNS 简介 2. DNS 服务器提供的功能 3. 分布式、层次数据库 4. DNS 查询方法 5. DNS 缓存和权威 DNS 服务器记录更新 6. DNS 记录 7. DNS 报文 8. 在 DNS 数据库中插入记录 9. DNS 攻击 1. DNS 简介 名称&#xff1a;Domain Name System DNS 是&#xff1a; …

vue面试题(day06)

文章目录前言请谈谈WXML与标准的html的异同&#xff1f;请谈谈WXSS和CSS的异同&#xff1f;请谈谈微信小程序主要目录和文件的作用&#xff1f;请谈谈小程序的双向绑定和vue的异同&#xff1f;简单描述下微信小程序的相关文件类型&#xff1f;微信小程序有哪些传值(传递数据)方…

【新星计划2023】SQL SERVER (01) -- 基础知识

【新星计划2023】SQL SERVER -- 基础知识1. Introduction1.1 Official Website1.2 Conn Tool2. 基础命令2.1 建库建表2.2 Alter2.3 Drop2.3 Big Data -- Postgres3.Awakening1. Introduction 1.1 Official Website 官方文档&#xff08;小技巧&#xff09; Officail Website: …

十个Python图像处理工具,不可不知

这些Python库提供了一种简单直观的方法来转换图像并理解底层数据。 今天的世界充满了数据&#xff0c;图像是这些数据的重要组成部分。但是&#xff0c;在使用它们之前&#xff0c;必须对这些数字图像进行处理 - 分析和操作&#xff0c;以提高其质量或提取一些可以使用的信息。…

【C++学习】继承

&#x1f431;作者&#xff1a;一只大喵咪1201 &#x1f431;专栏&#xff1a;《C学习》 &#x1f525;格言&#xff1a;你只管努力&#xff0c;剩下的交给时间&#xff01; C是面向对象的编程语言&#xff0c;它有很多的特性&#xff0c;但是最重要的就是封装&#xff0c;继承…

【3DoF算法】

VR 3DoF算法介绍 核心&#xff1a;3DoF算法应用场景&#xff0c;在VIO应用中&#xff0c;当只有测量没有观测的情况下&#xff0c;6DoF算法的预测会退化成一个只有测量的3DoF算法&#xff0c;这时候需要使用3DoF算法&#xff0c;来更加稳定准确的获取3DoF位姿&#xff0c;直到…

【VSCode】Windows 下搭建 Fortran 环境

文章目录Part.I 预备知识Part.II 安装与配置Chap.I 编译环境Chap.II 插件Part.III 测试Chap.I 一个示例Chap.II 注意事项Part.I 预备知识 Fortran 是一种比较古老的语言了&#xff0c;当时作为一种科学计算工具&#xff0c;还是比较火的&#xff0c;因为很多有名的软件都是基于…

LFM雷达实现及USRP验证【章节2:LFM雷达测距】

目录 1. 参数设计 几个重要的约束关系 仿真参数设计 2. matlab雷达测距代码 完整源码 代码分析 回顾&#xff1a;LFM的基本原理请详见第一章 本章节将介绍LFM雷达测距的原理及实现 1. 参数设计 几个重要的约束关系 带通采样定理&#xff1a; 因此如果我们B80MHz时&a…

SQL优化13连问,收藏好!

1.日常工作中&#xff0c;你是怎么优化SQL的&#xff1f; 大家可以从这几个维度回答这个问题&#xff1a; 分析慢查询日志 使用explain查看执行计划 索引优化 深分页优化 避免全表扫描 避免返回不必要的数据&#xff08;如select具体字段而不是select*&#xff09; 使用…

【Android -- 开发工具】Xshell 6 安装和使用教程

一、简介 Xshell 其实就是一个远程终端工具&#xff0c;它可以将你的个人电脑和你在远端的机器连接起来&#xff0c;通过向 Xshell 输入命令然后他通过网络将命令传送给远端Linux机器然后远端的Linux机器将其运行结果通过网络传回个人电脑。 二、Xshell 6 的安装 首先&#…

如何通过命令行查看CentOS版本信息和linux系统信息

1.如何查看已安装的CentOS版本信息&#xff1a; 1.cat /proc/version 2.uname -a 3.uname -r 4.cat /etc/centos-release 5.lsb_release -a 6.hostnamectl1. 第一种方式输出的结果是&#xff1a; Linux version 3.10.0-1127.el7.x86_64 (mockbuildkbuilder.bsys.centos.org) …

算法基础-回溯算法

回溯算法大致分为以下几类&#xff1a; 组合&#xff1a;组合、组合总和、电话号码的字母组合 分割&#xff1a;分割回文串、复原IP地址 子集&#xff1a;子集 排列&#xff1a;全排列 棋盘问题&#xff1a;N皇后、解数独 其他&#xff1a;递增子序列、重新安排行程 一、什么是…

gns3:动态路由(ospf) area0 骨干网络(域间)(ABR)+ ospf 连接 rip (外部)(ASBR)+ 区域划分

1.配置好接口ip 全部处于up状态2.配置好lookback口 增加一个虚拟直连网段全部为 255.255.255.0的子网掩码实现上边ospf之间通信r1的全局模式router ospf 1network 192.168.1.0 0.0.0.255 area 1network 1.1.1.0 0.0.0.255 area 1宣告直连 并且划分area 区域为1r2全局模式router…

一种LCD屏闪问题的调试

背景 项目使用ESP32-S3 RGB接口驱动的LCD, 框架 idf-v5.0, LVGL-v7.11 显示画面正常, 但肉眼可见的像是背光在闪烁, 背光电路是应用很久的经典电路, 且排查背光驱动无错, 但开机一段时间后, 闪烁会明显减轻 记录 这块屏的显示驱动芯片为ST7701S, 查看芯片手册有说明特定的上…

全网最完整,接口测试总结彻底打通接口自动化大门,看这篇就够了......

目录&#xff1a;导读前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09;前言 所谓接口&#xff0…

音视频开发—MediaCodec 解码H264/H265码流视频

使用MediaCodec目的 MediaCodec是Android底层多媒体框架的一部分&#xff0c;通常与MediaExtractor、MediaMuxer、AudioTrack结合使用&#xff0c;可以编码H264、H265、AAC、3gp等常见的音视频格式 MediaCodec工作原理是处理输入数据以产生输出数据 MediaCodec工作流程 Med…

SpringBoot整合Flink(施耐德PLC物联网信息采集)

SpringBoot整合Flink&#xff08;施耐德PLC物联网信息采集&#xff09;Linux环境安装kafka前情&#xff1a;施耐德PLC设备&#xff08;TM200C16R&#xff09;设置好信息采集程序&#xff0c;连接局域网&#xff0c;SpringBoot订阅MQTT主题&#xff0c;消息转至kafka&#xff0c…

计算机网络体系结构——“计算机网络”

各位CSDN的uu们你们好呀&#xff0c;今天小雅兰来学习一个全新的知识点&#xff0c;就是计算机网络啦&#xff0c;下面&#xff0c;开始虚心学习。 计算机网络的概念 计算机网络的功能 计算机网络的组成 计算机网络的分类 标准化工作 计算机网络的性能 计算机网络的概念 …

Hadoop集群环境配置搭建

一、简单介绍 Hadoop最早诞生于Cutting于1998年左右开发的一个全文文本搜索引擎 Lucene&#xff0c;这个搜索引擎在2001年成为Apache基金会的一个子项目&#xff0c;也是 ElasticSearch等重要搜索引擎的底层基础。 项目官方&#xff1a;https://hadoop.apache.org/ 二、Linux环…