定时器的使用和实现

目录

一.定时器Timer类的主要方法

二.定时器Timer类的使用 

三.定时器的模拟实现

一.定时器Timer类的主要方法

定时器Timer类在java.util包中。

使用前先进行实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定指定的任务task在指定的延迟delay (ms)后运行。要安排的任务就是一个Runnable,定时器任务类TimerTask是抽象类，继承TimerTask并重写其run()方法，可实现要完成的任务。
schedule(TimerTask task, Date time)将指定的任务安排在指定的时间执行，如果时间是过去的时间，任务将被调度为立即执行。
cancel()方法结束这个定时器。
要实现一个定时任务，运用java中的Timer类和TimerTask类能够现实时调用处理函数。

二.定时器Timer类的使用 

 一个定时器,可以同时往里面安排多个任务

import java.util.Timer;
import java.util.TimerTask;

public class Demo3 {
    public static void main(String[] args) {
        Timer timer = new Timer();//先实例化一个对象

        timer.schedule(new TimerTask() {
            @Override
            public void run() {//重写run方法
                System.out.println("2.时间到,该写作业了");
            }
        },4000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("3.时间到,该吃饭了");
            }
        },5000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("1.时间到,该学习了");
            }
        },3000);
        System.out.println("开始计时");
    }
}

运行结果:

运行的顺序时按照延迟的时间来运行的

在第二个任务的run方法中加入cancel就会在当前正在执行的任务结束后,结束进程,不会再继续执行后面剩余的任务

    timer.schedule(new TimerTask() {
        @Override
        public void run() {//重写run方法
            System.out.println("2.时间到,该写作业了");
            timer.cancel();
        }
    },4000);

 运行结果:

三.定时器的模拟实现

 schedule的第一个参数是一个要执行的任务

需要描述这个任务就包含两个方面的信息,一个是要执行啥工作,另一个是啥时候执行

class MyTask {
    private Runnable runnable;//执行的任务
    private long time;//什么时候执行,是一个时间戳

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

Timer是能够安排多个任务的,而不同的任务执行的时间又不相同,就需要有一个存储空间来存储

如果使用ArrayList的话,里面的元素是无序的,每次安排进去一个新的任务就得进行一次查找当前最先执行的任务,需要耗费O(n)的时间,所以需要一个每次一拿就能拿到最先执行的任务,就需要使用优先级队列,但是优先级队列PriorityQueue是线程不安全的,而我们的schedule是可能在多线程当中进行调用,就可能会出现问题,而阻塞队列的线程是安全的,使用优先级阻塞队列能够完成这项工作

BlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

 此时安排任务就是有序又线程安全的了

有了这个队列后就需要创建一个单独的线程不断地来进行扫描队首元素,查看时间是否到了,到了就执行任务,而阻塞队列无法阻塞的取队首元素,所以时间没到就得把任务给放回去

MyTask2里面还需要有两个get方法来让外面的程序拿到任务和时间

public Runnable getRunnable() {
    return runnable;
}

public long getTime() {
    return time;
}

还需要一个schedule方法来安排任务,将任务放进去队列当中去

class MyTimer2{
    private BlockingQueue<MyTask2> queue = new PriorityBlockingQueue<MyTask2>();

    public MyTimer2(){
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    MyTask2 task2 = queue.take();//获取首任务
                    if (System.currentTimeMillis() >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                        task2.getRunnable().run();//时间到了,开始执行任务
                    } else {//时间未到,放回队列
                        queue.put(task2);
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();//启动线程
    }
    public void schedule(Runnable runnable,long after) throws InterruptedException {
        MyTask2 myTask2 = new MyTask2(runnable,after);//创建一个新的任务
        queue.put(myTask2);//将任务放进队列
    }
}
public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        MyTimer2 timer = new MyTimer2();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("时间到!");
            }
        },5000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余1秒!");
            }
        },4000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余2秒!");
            }
        },3000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余3秒!");
            }
        },2000);

        System.out.println("开始计时!");
    }
}

此时运行程序的时候就会发现一个问题

 发生了类型转换异常,所以在MyTask2里面还需要一个比较器

    public int compareTo(MyTask2 o) {
        return (int) (this.time - o.time);//此处得判断是谁减谁,可以让程序运行一下就可以判断,还需要进行类型转换
    }

 运行结果:

 

 但此时程序严重的问题

即程序一直处于循环的等待,等待过程中光看时间,完全做不了别的事情,而看时间对整个任务的进程没啥影响,此时CPU并没有空闲出来,这个循环就是在忙等,那这里的等待就没有意义了

例如:

如果使用sleep方法的话并不太行,因为如果当前的时间是0:00而第一个任务的执行时间是2:00,此时需要sleep2个小时,然后在这个过程中加入了一个新的任务在1:00执行,但此时程序sleep了,该任务就会错过执行的时间,导致工作线程无法在1:00执行此任务

使用wait和notify就可以解决这个问题

class MyTimer2{
    private BlockingQueue<MyTask2> queue = new PriorityBlockingQueue<MyTask2>();
    public Object locker = new Object();

    public MyTimer2(){
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    MyTask2 task2 = queue.take();
                    long curTime = System.currentTimeMillis();
                    if (curTime >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                        task2.getRunnable().run();//时间到了,开始执行任务
                    } else {//时间未到,放回队列
                        queue.put(task2);
                        synchronized (locker){
                            locker.wait(task2.getTime() - curTime);
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();//启动线程
    }
    public void schedule(Runnable runnable,long after) throws InterruptedException {
        MyTask2 myTask2 = new MyTask2(runnable,after);//创建一个新的任务
        queue.put(myTask2);//将任务放进队列
        synchronized (locker){
            locker.notify();//当加入一个新的任务后,notify能够唤醒上方的wait,扫描线程将会重新获取首任务,再次判断
        }
    }
}

但该程序仍存在一个问题

 因为当前的环境是多线程的环境,所以如果扫描线程拿到首任务task2后,然后再wait等待之前,线程切换到了schedule线程,schedule线程新增一个新的任务,而当前新的任务执行时间是在上面所取到的task2之前,然后线程切换回MyTimer2,从刚刚的地方继续往下执行,然后就会进行wait等待task2开始执行的时间,一样会造成新任务没办法按时执行,该问题产生的原因就是因为操作不是原子的

 所以需要将上方第一把锁的范围扩大,读比等操作都在同一把锁里面

public MyTimer2(){
    Thread t = new Thread(() -> {
        while(true) {
            try {
                synchronized (locker){//将🔒的范围扩大
                    MyTask2 task2 = queue.take();
                    long curTime = System.currentTimeMillis();
                    if (curTime >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                        task2.getRunnable().run();//时间到了,开始执行任务
                    } else {//时间未到,放回队列
                        queue.put(task2);
                        locker.wait(task2.getTime() - curTime);
                    }
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
    t.start();
}

此时将锁的范围扩大后就可以避免了notify在take和wait之间执行,扫描线程会先拿到锁,然后take,然后中间逻辑,一直到wait

在这个过程中,schedule线程会阻塞等待锁,直到扫描线程执行到了wait之后,扫描线程释放了锁schedule线程就拿到了锁,新增任务后,notify通知,wait就被立刻唤醒了,接下来重新获取队首元素,就把新增的任务取出来了

完整代码

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;

class MyTask2 implements Comparable<MyTask2>{
    private Runnable runnable;
    private long time;

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

    public Runnable getRunnable() {
        return runnable;
    }

    public long getTime() {
        return time;
    }


    @Override
    public int compareTo(MyTask2 o) {
        return (int) (this.time - o.time);
    }
}

class MyTimer2{
    private BlockingQueue<MyTask2> queue = new PriorityBlockingQueue<MyTask2>();
    public Object locker = new Object();

    public MyTimer2(){
        Thread t = new Thread(() -> {
            while(true) {
                try {
                    synchronized (locker){
                        MyTask2 task2 = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task2.getTime()) {//当前运行时间和任务开始执行的时间进行对比
                            task2.getRunnable().run();//时间到了,开始执行任务
                        } else {//时间未到,放回队列
                            queue.put(task2);
                            locker.wait(task2.getTime() - curTime);
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
    }
    public void schedule(Runnable runnable,long after) throws InterruptedException {
        MyTask2 myTask2 = new MyTask2(runnable,after);//创建一个新的任务
        queue.put(myTask2);//将任务放进队列
        synchronized (locker){
            locker.notify();
        }
    }
}

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        MyTimer2 timer = new MyTimer2();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("时间到!");
            }
        },5000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余1秒!");
            }
        },4000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余2秒!");
            }
        },3000);

        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("剩余3秒!");
            }
        },2000);

        System.out.println("开始计时!");
    }
}

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

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

相关文章

跟着小白学linux的基础命令

跟着小白学linux的基础命令

小白学习记录&#xff1a; 前情提要&#xff1a;Linux命令基础格式!查看 lsLinux 的7种文件类型及各颜色代表含义 进入指定目录 cd查看当前工作目录 pwd创建一个新的目录(文件夹&#xff09; mkdir创建文件 touch查看文件内容 cat、more操作文件、文件夹- 复制 cp- 移动 mv- 删…
阅读更多...
从混乱到有序：PDM系统如何优化物料编码

从混乱到有序：PDM系统如何优化物料编码

在现代制造业中&#xff0c;物料管理是企业运营的核心。物料编码作为物料管理的基础&#xff0c;对于确保物料的准确性、唯一性和高效性至关重要。随着产品种类的不断增加和产品变型的多样化&#xff0c;传统的物料编码管理方式已经不能满足企业的需求。本文将探讨产品数据管理…
阅读更多...
SOLIDWORKS参数化设计插件 慧德敏学

SOLIDWORKS参数化设计插件 慧德敏学

SOLIDWORKS软件是法国达索公司的产品&#xff0c;最初是满足欧美一些工程师产品设计需要而开发的&#xff0c;并没有考虑中国的企业实际情况。我们为满足国内客户的需要&#xff0c;对SOLIDWORKS进行了二次开发&#xff0c;借助SolidKits.AutoWorks参数化工具&#xff0c;通过一…
阅读更多...
计算机网络-OSI七层参考模型与数据封装

计算机网络-OSI七层参考模型与数据封装

目录 一、网络 1、网络的定义 2、网络的分类 3、网络的作用 4、网络的数据传输方式 5、网络的数据通讯方式 二、OSI七层参考模型 1、网络参考模型定义 2、分层的意义 3、分层与功能 4、TCP\IP五层模型 三、参考模型的协议 1、物理层 2、数据链路层 3、网络层 4…
阅读更多...
SQL面试问题集

SQL面试问题集

目录 Q.左连接和右连接的区别 Q.union 和 union all的区别 1、取结果的交集 2、获取结果后的操作 Q.熟悉开窗函数吗&#xff1f;讲一下row_number和dense_rank的区别。 Q.hive行转列怎么操作的 Q.要求手写的题主要考了聚合函数和窗口函数&#xff0c;row_number()&#…
阅读更多...
SSM旅游论坛（前后分离源码+论文）

SSM旅游论坛（前后分离源码+论文）

该旅游论坛是基于Spring、SpringMVC、Mybatis框架开发出来的 用户信息管理 此页面提供给管理员的功能有&#xff1a;用户信息的查询管理&#xff0c;可以删除用户信息、修改用户信息、新增用户信息&#xff0c; 还进行了对用户名称的模糊查询的条件 景点信息管理 论坛类型管理…
阅读更多...
走进 Apache 世界的另一扇大门

走进 Apache 世界的另一扇大门

引言 作为热爱技术的你&#xff0c;是否也羡慕 Apache PMC 或者 Committer&#xff0c;此篇文章渣渣皮带你迈出如何成为技术大牛的第一步。 当然我现在还是一枚小小的 code contributor&#xff0c;在成为 committer 的路上还在奋力打码中&#xff0c;写这篇文章也是为大家有…
阅读更多...
C# Interlocked 原子操作

C# Interlocked 原子操作

目录 注解 方法 适用于 案例 1&#xff1a;Add 对两个整数进行求和并用和替换第一个整数&#xff0c;上述操作作为一个原子操作完成 2&#xff1a;Exchange Exchange(UInt32, UInt32) 以原子操作的形式&#xff0c;将 32 位无符号整数设置为指定的值并返回原始值。 参考…
阅读更多...
存储设备有哪些？属于私有云平台吗？怎么理解？

存储设备有哪些？属于私有云平台吗？怎么理解？

数字化的今天&#xff0c;数据已经成为了企业最重要最宝贵的资产了。为了保障数据的安全、可靠和高效利用&#xff0c;存储设备和云计算技术应运而生。今天我们大家就来聊聊存储设备有哪些&#xff1f;属于私有云平台吗&#xff1f;怎么理解&#xff1f; 存储设备有哪些&…
阅读更多...
thinkadmin发邮件功能如何设置？怎么使用？

thinkadmin发邮件功能如何设置？怎么使用？

thinkadmin发邮件有哪些注意事项&#xff1f;支持哪些邮件服务&#xff1f; 在使用thinkadmin框架进行开发时&#xff0c;发邮件功能的设置是一个常见的需求。通过合理配置和简单的编程&#xff0c;我们可以轻松地在thinkadmin中集成邮件发送功能。AokSend将详细介绍如何设置t…
阅读更多...
动态规划9：LCR 099. 最小路径和

动态规划9：LCR 099. 最小路径和

动态规划解题步骤&#xff1a; 1.确定状态表示&#xff1a;dp[i]是什么 2.确定状态转移方程&#xff1a;dp[i]等于什么 3.初始化&#xff1a;确保状态转移方程不越界 4.确定填表顺序&#xff1a;根据状态转移方程即可确定填表顺序 5.确定返回值 题目链接&#xff1a;LCR …
阅读更多...
在VS Code中操作MySQL数据库

在VS Code中操作MySQL数据库

创建MySQL连接 操作前需要先启动MySQL数据库&#xff0c;个别情况下需要以管理员身份打开cmd&#xff0c;在cmd中输入&#xff1a; net start mysql 我的MySQL数据库服务名为mysql84&#xff0c;需要填写自己的mysql服务名称。 随后在VS Code中下载插件 Prettier SQL VSCode …
阅读更多...
新手必看！场外期权交易的六大注意事项

新手必看！场外期权交易的六大注意事项

场外期权交易的六大注意事项 对于初涉金融市场的投资者来说&#xff0c;场外期权交易无疑是一个既具吸引力又充满挑战的领域。为确保您在交易中能够稳健获利&#xff0c;以下六大注意事项值得每位新手仔细研读。 文章来源/&#xff1a;财智财经 一、深入理解期权基本概念 场…
阅读更多...
海思SS928（SD3403）部署YOLOv5-YOLOv7步骤详解

海思SS928（SD3403）部署YOLOv5-YOLOv7步骤详解

1. YOLO模型资料 本文档内容以yolov5-7.0工程、yolov5s模型为例。 a. 模型结构 详细的模型结构可以利用netron工具打开.pt或.onnx模型查看。 b. 模型参数即验证结果 其中，YOLOv5n、YOLOv5s、YOLOv5m、YOLOv5l、YOLOv5x为五种类型的预训练模型，其包含的检测类别相…
阅读更多...
数据中心运维如何使用布线管理软件

数据中心运维如何使用布线管理软件

1. 什么是可视化布线管理软件 1.1 数据中心布线管理软件部署在本地服务器&#xff0c;通过数据导入将现有的数据中心布线系统的设备信息、线缆连接关系等导入到管理软件中形成数据库&#xff1b; 1.2 布线管理软件提供了实时可视化的管理界面&#xff0c;从园区到建筑到楼…
阅读更多...
LabVIEW与Simulink的通信及调用方式

LabVIEW与Simulink的通信及调用方式

LabVIEW和Simulink可以通过多种方式进行通信和集成&#xff0c;实现数据交互和功能调用。常见的通信方式包括TCP/IP、UDP、共享内存等&#xff0c;此外还可以利用MATLAB Script Node和S-Function等直接调用对方的功能。这些方法使得LabVIEW和Simulink能够协同工作&#xff0c;充…
阅读更多...
AI-知识库搭建（一）腾讯云向量数据库使用

AI-知识库搭建（一）腾讯云向量数据库使用

一、AI知识库 将已知的问答知识&#xff0c;问题和答案转变成向量存储在向量数据库&#xff0c;在查找答案时&#xff0c;输入问题&#xff0c;将问题向量化&#xff0c;匹配向量库的问题&#xff0c;将向量相似度最高的问题筛选出来&#xff0c;将答案提交。 二、腾讯云向量数…
阅读更多...
龙讯旷腾PWmat团队研发的开源机器学习力场PWMLFF升级，新增高效训练NEP模型

龙讯旷腾PWmat团队研发的开源机器学习力场PWMLFF升级，新增高效训练NEP模型

近几年来&#xff0c;一种结合了物理学、高性能并行计算和机器学习算法的新的科研范式——AI for science迅速崛起&#xff0c;并为解决精度与尺度无法并存的问题带来了曙光。基于机器学习力场&#xff08;machine learning force field, MLFF&#xff09;的分子动力学&#xf…
阅读更多...
Vue2自定义拖拽指令-元素拖拽

Vue2自定义拖拽指令-元素拖拽

Vue2自定义拖拽指令-元素拖拽-参数传递 v-canDraghtml部分/src/directive/canDrag/index.js然后注册到vue实例上就OK了 v-canDrag html部分 <template><div class"drag-container"><div class"drag-div" v-canDrag"{callback:callbac…
阅读更多...
新能源集成灶怎么样？不需要燃料就能生火，是真的吗？

新能源集成灶怎么样？不需要燃料就能生火，是真的吗？

在当今的厨房电器领域&#xff0c;集成灶的出现引起了不少网友的广泛关注。这不&#xff0c;就在刚刚人民日报发布的一篇名为《中国新能源产业发展是全球性贡献和机遇》报道中提到&#xff1a;中国新能源产品销量突破万亿大关&#xff0c;中国新能源技术全球领先。从这样一份亮…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站