定时器的使用及实现

最新推荐文章于 2024-06-07 10:53:19 发布
最新推荐文章于 2024-06-07 10:53:19 发布
阅读量775 收藏 13
点赞数 17
文章标签： java 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_78892316/article/details/134810458
版权

在Java中，定时器（Timer）是一个用于执行任务的工具类。它可以安排任务在指定的时间点执行，或者按照指定的时间间隔周期性地执行。

1. Timer类

Timer类位于java.util包中，它提供了一种简单而便利的方式来安排以后的任务执行。Timer类的核心思想是创建一个后台线程，在指定的时间点执行任务或者按照指定的时间间隔周期性地执行任务。以下是Timer类的几个重要概念：

  • Timer对象：通过Timer timer = new Timer();语句创建一个Timer对象，用于安排任务的执行。
  • TimerTask对象：TimerTask是一个抽象类，表示要执行的任务。通常需要创建一个继承自TimerTask的具体任务类，并重写其中的run()方法，定义要执行的任务逻辑。

安排任务的执行
使用Timer类安排任务的执行通常需要以下步骤：

  1. 创建Timer对象：通过Timer timer = new Timer();语句创建一个Timer对象。
  2. 创建任务：创建一个继承自TimerTask类的具体任务类，重写其中的run()方法，定义要执行的任务逻辑。
  3. 安排任务执行：使用schedule()方法安排任务的执行。可以通过指定任务、延迟时间和执行周期等参数来安排任务的执行时间和频率。例如：timer.schedule(task, delay, period);

具体任务类需要重写TimerTask类中的run()方法，定义要执行的任务逻辑。例如：

class MyTask extends TimerTask {
    public void run() {
        // 执行具体的任务逻辑
        System.out.println("Hello");
    }
}

最后，调用timer.schedule()方法启动定时器，将任务安排到定时器中进行执行。

public class ThreadDemo25 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask t = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Ting");
            }
        };
        
        //3000ms后执行 t
        timer.schedule(t, 3000);
    }
}

一个Timer可以加入多个任务：

public class ThreadDemo25 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("C");
            }
        }, 3000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("B");
            }
        }, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("A");
            }
        }, 1000);
    }
}

注意：Timer对象会创建一个线程，并且这个线程是一个前台线程。

注意：Timer这个线程不会主动结束，除非调用 cansel 方法

2. 实现一个Timer类

 思考一下 Timer 需要包含哪些内容

1. 需要有一个能数组/队列来存储要执行的任务

2. 需要一个线程负责执行任务

由于，每个任务执行的时间不同，我们可以让先执行的任务排在前面，每次只用看第一个任务是否到达执行时间即可，所以我们可以使用一个优先级队列来存储任务。

class MyTimer {
    //存储用于执行的任务
    private PriorityQueue<> q = new PriorityQueue<>();
    //负责执行的线程
    Thread t = null;

    public MyTimer() {
        //在构造方法中实现并运行线程
        t = new Thread(() -> {

        });
        t.start();
    }

    public void schedule(Runnable runnable, int daley) {
        //用来添加任务，和执行的时间
    }
}

我们已经有了Timer的大概框架，我们还需要实现一个MyTimerTask 来关联任务和执行时间，放在我们的优先级队列中：

class MyTimerTask implements Comparable<MyTimerTask> {
    //执行任务的时间，这里约定为一个毫秒级时间戳
    private long time;
    //任务，这里也可以直接实现Runnab接口
    private Runnable runnable;

    public MyTimerTask(Runnable runnable, int daley) {
        this.runnable = runnable;
        //将相对时间转化为时间戳
        time = System.currentTimeMillis() + daley;
    }

    public long getTime() {
        return time;
    }

    //在这里提供执行任务的方法
    public void run() {
        runnable.run();
    }

    //由于我们的MyTimerTask 是需要放在优先级队列中的，所以需要可比较
    //于是我们可以实现Comparable接口，以执行间隔时间比较大小    
    @Override
    public int compareTo(MyTimerTask o) {
        return (int)(this.time - o.time);
    }
}

现在我们可以进一步实现schedule方法：

   public void schedule(Runnable runnable, int daley) {
        MyTimerTask task = new MyTimerTask(runnable, daley);
        q.offer(task);//添加到队列中
    }

现在我们只需要实现MyTimer中具体的线程 t 即可：

        public MyTimer() {
            t = new Thread(() -> {
                while(true) {
                    //队列为空
                    if (q.isEmpty()) {
                        continue；
                    }

                    MyTimerTask run = q.peek();
                    long CurTime = System.currentTimeMillis();

                    if (run.getTime() <= CurTime) {
                        q.poll();
                        //开始执行
                        run.run();
                    }else {
                        //还未到执行时间
                        continue；
                    }
                }
            });
            t.start();
        }

在上述代码中我们实现了 t 线程的大概框架，我们发现，t 线程中存在一个 poll 操作,而上面的schedule方法中存在 offer 操作，并且这个操作是在 main线程中完成的，两个线程都在对同一个队列进行读写操作，可能会有线程安全问题，所以我们 需要给，t线程中和 schedule 方法中都加上锁。

    public void schedule(Runnable runnable, int daley) {
        MyTimerTask task = new MyTimerTask(runnable, daley);
        synchronized (locker) {
            q.offer(task);
        }
    }

 

    public MyTimer() {
        t = new Thread(() -> {
            while(true) {
                synchronized (locker) {
                    //队列为空
                    if (q.isEmpty()) {
                        continue;
                    }

                    MyTimerTask run = q.peek();
                    long CurTime = System.currentTimeMillis();

                    if (run.getTime() <= CurTime) {
                        q.poll();
                        //开始执行
                        run.run();
                    }else {
                        //还未到执行时间
                        countine;
                    }
                }
            }
        });
        t.start();
    }

与此同时，如果队列为空，t 线程中会直接 coutine 进入下一次 循环，这个循环速度是非常快的，有可能 ，t 线程释放锁之后有拿到锁了，导致线程饿死，所以我们 这里可以使用 wait 等待，并在schedule 中 添加任务成功后，调用notify，同理：如果某个任务的执行时间没到，也会一直循环，所以我们可以把下面 else 中的 continue 换成 notify ：

    public void schedule(Runnable runnable, int daley) {
        MyTimerTask task = new MyTimerTask(runnable, daley);
        synchronized (locker) {
            q.offer(task);
            locker.notify();
        }
    }
    public MyTimer() {
        t = new Thread(() -> {
            while(true) {
                synchronized (locker) {
                    //队列为null阻塞等待
                    while (q.isEmpty()) {
                        try {
                            locker.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    MyTimerTask run = q.peek();
                    long CurTime = System.currentTimeMillis();

                    if (run.getTime() <= CurTime) {
                        q.poll();
                        //开始执行
                        run.run();
                    }else {
                        //还未到执行时间，等待notify唤醒，或者到执行时间
                        try {
                            locker.wait(run.getTime() - CurTime);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        t.start();
    }

分析一遍上面代码：进入 t 线程，如果队列为 空 ，阻塞等待，直到调用 schedule 添加任务后 notify 取消阻塞，然后进入下面，判断是否到了执行时间，如果到了就出队列，然后执行，没到执行时间则阻塞等待，直到到达执行时间，或者添加了新任务 调用notify 取消阻塞，注意这里：添加新任务后，这个任务的执行时间可能为当前队列中最早的，所以要进入下一次循环重新peek，确保拿到的一定是队列中最早执行的任务。

下面来看一下整体代码和执行效果：

class MyTimer {
    //存储用于执行的任务
    private PriorityQueue<MyTimerTask> q = new PriorityQueue<>();
    //负责执行的线程
    Thread t = null;
    Object locker = new Object();
    public MyTimer() {
        t = new Thread(() -> {
            while(true) {
                synchronized (locker) {
                    //队列为null阻塞等待
                    while (q.isEmpty()) {
                        try {
                            locker.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    MyTimerTask run = q.peek();
                    long CurTime = System.currentTimeMillis();

                    //未到执行时间阻塞等待
                    if (run.getTime() <= CurTime) {
                        q.poll();
                        //开始执行
                        run.run();
                    }else {
                        //还未到执行时间，等待notify唤醒，或者到执行时间
                        try {
                            locker.wait(run.getTime() - CurTime);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        t.start();
    }

    public void schedule(Runnable runnable, int daley) {
        MyTimerTask task = new MyTimerTask(runnable, daley);
        synchronized (locker) {
            q.offer(task);
            locker.notify();
        }
    }
}

class MyTimerTask implements Comparable<MyTimerTask> {
    //执行任务的时间
    private long time;
    //任务
    private Runnable runnable;

    public MyTimerTask(Runnable runnable, int daley) {
        this.runnable = runnable;
        time = System.currentTimeMillis() + daley;
    }
    public long getTime() {
        return time;
    }
    public void run() {
        runnable.run();
    }

    @Override
    public int compareTo(MyTimerTask o) {
        return (int)(this.time - o.time);
    }
}
public class ThreadDemo26 {
    public static void main(String[] args) {
        MyTimer timer = new MyTimer();

        timer.schedule(() -> {
            System.out.println("3");
        }, 3000);

        timer.schedule(() -> {
            System.out.println("2");
        }, 2000);

        timer.schedule(() -> {
            System.out.println("1");
        }, 1000);
    }
}

 

odoo12：定时任务
qq_43239192的博客
02-27 1878
odoo12：定时器任务   设置--技术-自动化-安排的动作  代码如下： &lt;record id="ir_cron_scheduler_action" model="ir.cron"&gt; &lt;field name="name"&gt;定时器&lt;/field&gt; &lt;field name="
基于VHDL的99小时定时器设计及实现
01-19
完全可以满足用户的需要，使用也更为方便。 　1 系统原理 　本定时器的器件为EP1C6Q240C8芯片。该芯片有选位、置位、启动、复位、倒计时等功能，显示采用2个3位LED数码管，并采用共阴接法，可以动态扫描显示。其...
Java中Timer的用法
热门推荐
imzoer的专栏
01-14 13万+
现在项目中用到需要定时去检查文件是否更新的功能。timer正好用于此处。 用法很简单，new一个timer，然后写一个timertask的子类即可。 代码如下： package comz.autoupdatefile; import java.util.Timer; import java.util.TimerTask; public class M { public st
定时器的用法
weixin_34348805的博客
12-26 228
这里是修真院前端小课堂，每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面深度解析前端知识/技能，本篇分享的是： 【 定时器的用法】 大家好，我是IT修真院北京分院第22期的学员杨纲，一枚正直纯洁善良的WEB前端程序员。 1.背景介绍 什么是定时器？ JS提供了一些原生...
JAVA中定时器的使用
weixin_34413802的博客
02-17 127
在JAVA中实现定时器功能要用的二个类是Timer,TimerTask       Timer类是用来执行任务的类，它接受一个TimerTask做参数Timer有两种执行任务的模式,最常用的是schedule,它可以以两种方式执行任务:1:在某个时间(Data)，2:在某个固定的时间之后(int delay).这两种方式都可以指定任务执行的频率,本文有二个例子,一个是简单的一个是用了内部类1.简单...
定时器使用方法
Solidfish的专栏
08-29 1484
定时器使用方法定时器在VC中的使用频繁，以下讨论定义器的使用方法。　　定时器的原型是:　　WINUSERAPI UINT WINAPI SetTimer ( HWND hWnd , UINT nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc);　　hWnd          是欲设置定时器的窗体句柄。定时时间到时，系统会向该窗体发送WM_TIMER
linux使用select实现精确定时器详解
01-10
在编写程序时，我们经常会用到定时器。首先看看select函数原型如下： 代码如下:int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);参数说明：slect的第一个...
AVR使用范例-定时器实现PWM功能.docx
10-24
AVR 使用范例--定时器实现 PWM 功能 本文档讲述了使用 AVR 单片机实现 PWM 功能的方法，通过使用定时器 timer0 实现 PWM 输出。在本文档中，我们将详细介绍 PWM 的原理、AVR 单片机的定时器实现 PWM 功能、程序代码...
一个定时器实现多个虚拟定时器具体代码实现
03-23
6. **并发与同步**：在多线程环境下，虚拟定时器的实现需要考虑线程安全问题，可能需要使用锁或其他同步机制来防止数据竞争。 7. **可扩展性与灵活性**：好的虚拟定时器设计应该允许添加新功能，如暂停、恢复、取消...
游戏开发笔记之七——基础动画显示（一）定时器的使用
永不放弃_浪子文---------------黑客文化
05-13 564
定时器的使用 定时器（Timer）对象可以每隔一段时间发出一个时间消息，程序一旦接收到此消息之后，便可以决定接下来要做哪些事情。这样的一个特性刚好可以适合播放静态的连续图片，产生动画的效果。下面来介绍如何建立与使用定时器。 建立定时器 Windows API 的SetTimer()函数可为窗口建立一个定时器，并说每隔一段时间就发出WM_TIMER消息，此函数的定义是
定时器使用
qq_50977605的博客
08-23 1421
定时器详解
如何使用定时器
ssihc0的专栏
05-16 1350
2009-05-16 00:43:56 函数源型   UINT_PTR SetTimer(     //创建一个定时器         HWND hWnd,  // 所在线程的handler，如果这个值为Null而下面nIDEvent                    这个参数不为0，表示替换nIDEvent这个定时器         UINT_PTR nIDEvent,// 定时
定时器的使用
黄嘟嘟博客
04-01 1639
一、定时器的使用方法（1）打开总中断 //EA， CPU中断允许（总允许）位。（2）设置定时器工作方式 M1M0工作方式控制位 C/T定时器方式或计数器方式选择位 若C/T=1时, 为计数器方式; C/T = 0时, 为定时器方式。 GATE 定时器/计数器运行门控标志位 当GATE=1时, 只有INT0 (或INT1)引脚为高电平且TR0(或TR1 )
定时器执行任务
细节打败一切
10-26 474
java定时器 现象： 了解java定时器：schedule方法和scheduleAtFixedRate方法 定时器 区别一： schedule方法，定时任务，按照代码实际执行任务的时间进行固定频率的执行，不按照原来代码中设定的时间进行固定频率执行（以上次任务结束的时间作为下次任务时间开始的起点间隔算）。 scheduleAtFixedRate方法，定时任务，按照代码中指定的时间进行固定频率的执...
定时器的使用和实现
最新发布
qq_62949535的博客
06-07 1136
定时器的使用和实现
WinCC定时器使用指南
WinCC中的定时器是实现自动化控制的关键工具，通过理解其使用方法和配置技巧，用户可以设计出符合实际需求的高效自动化解决方案。对于初次接触WinCC的用户，建议参考相关的技术资料，如《WinCC中定时器使用方法介绍...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ting-yu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值
>