在多线程中自定义实现定时器（Timer）

已于 2023-01-20 17:12:18 修改
阅读量560 收藏
点赞数 1
文章标签： java 数据结构 设计模式 Powered by 金山文档
于 2023-01-19 12:03:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65431718/article/details/128732579
版权

一.前提概要：我们需要清楚理解的是：我们所实现的定时器，是对JDK中定时器的模仿和重现，与JDK提供的定时器类似，我们使用schedule（）方法实现对任务的添加，使用BlockingQueue来组织任务，使用定时器的构造方法完成对阻塞队列中的任务的检查和实现（在阻塞队列中检查取出和完成任务）

二.定时器的组成部分

  1. 创建MyTask类实现对任务的定义

在MyTask中核心主要是自定义的runnable方法以及实现的时间

除此之外我们需要自定义实现time和runnable的get()方法，以便满足后续定时器对这两个属性的调用

总体代码如下：

public class MyTask {
    private long time;
    private Runnable runnable;
//创建get任务和时间

    public long getTime() {
        return time;
    }

    public Runnable getRunnable() {
        return runnable;
    }
//创建构造方法
    public MyTask(Runnable runnable,long time){
        
        this.time=time+System.currentTimeMillis();
        this.runnable=runnable;
    }

}

但是如果是这样，当我们进行对该任务的测试时，我们才发现报出这样的异常：

如果大家学习过优先级队列（堆）的数据结构，我们队这个这个异常也就不陌生了：我们对自定义的实现类没有实现自定义的比较器或者comparable接口，所以为了避免这个异常，我们需要实现comparable接口，并重写compareTo()方法，（那为什么我们需要实现comparable接口呢？因为我们任务进行实现的数据结构是比较级的阻塞队列，该数据结构要求必须实现该接口或者重写比较器comparator）优化代码如下：

public class MyTask implements Comparable<MyTask>{
    private long time;
    private Runnable runnable;
//创建get任务和时间

    public long getTime() {
        return time;
    }

    public Runnable getRunnable() {
        return runnable;
    }
//创建构造方法
    public MyTask(Runnable runnable,long time){
        //判断时间的可靠性
        if(time<0){
            throw  new RuntimeException("时间错误");
        }
        this.time=time+System.currentTimeMillis();
        this.runnable=runnable;
    }
    @Override
    public int compareTo(MyTask o) {
        //第一种方式
       return (int)this.time-o.time;
      
}

我们实现了compareTo()方法，但是我们去看这个方法，我们发现它实现了一个由long到int的一个强制类型转化，尽管在绝大多数的情况下两个时间相减符合int类型的范围，但是仍存在整形变量由long强制转化为int出现的越界问题，为了避免该问题的出现，我们对compareTo()方法进行优化：

 public int compareTo(MyTask o) {
        //第一种方式
      //  return this.time-o.time;
        //为了防止越界，我们选择第二种比较方式
        if(this.time>o.time){
            return 1;
        }
        if(this.time==o.time){
            return  0;
        }
        else{
            return -1;
        }
    }

  1. 创建自定义类MyTimer实现对任务的组织调用和实现（使用PriorityBlockingQueue进行对任务的组织，schedule（）方法完成对任务的实现）

我们可以对任务加入阻塞队列和任务的取出的逻辑进行总结：

①将任务列入阻塞队列：直接利用put()方法放入即可

②将任务移出阻塞队列并实现：1.取出任务2.判断时间到没到，如果到了直接将任务执行，时间没有到，则将任务重新放入组赛队列即可

public class MyTimer {
    //创建锁对象
    private Object locker=new Object();
    //创建比较队列
    BlockingQueue<MyTask>queue=new PriorityBlockingQueue();
    //创建schedule方法,放入队列
    public void schedule(MyTask myTask) throws InterruptedException {
        queue.put(myTask);
    }
    //创建构造器，实现队列元素的取出
    public MyTimer(){
        //创建线程
        Thread thread=new Thread(()->{
            //创建循环
            while(true) {
                //扩大synchronized范围，保证原子性

                //取出元素
                try {
                    MyTask task = queue.take();
                    //判断是否到达该执行的时间
                    long time = System.currentTimeMillis();
                    if (time >= task.getTime()) {
                        //执行
                        task.getRunnable().run();
                    } else {
                        //重新放入
                        queue.put(task);
                    }


                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
        });
        thread.start();
 
    }
}

我们通过这两个类事实上已经基本能实现定时器的基本功能，仔细观察,我们不难发现其中的不足：

  1. 效率问题：当我们判定任务没有到时间时，我们选择的策略是将其重新放入阻塞队列，但是如果距离到达时间相对较长的话，不全的判断和取出会增加cpu的消耗，我们应该对此进行优化：在判断没有到时间时，我们计算需要等待的时间，先让线程wait()

  1. 如果线程wait之后，在此时我们新加入了一个比之前wait()时间结束靠前的任务：这时候线程处于阻塞状态，没办法按时执行任务，（我们称这个状态为忙等状态）这时候我们则需要在加入任务时对线程进行唤醒。代码优化如下：

Thread thread=new Thread(()->{
            //创建循环
            while(true) {
                //扩大synchronized范围，保证原子性

                //取出元素
                try {
                    MyTask task = queue.take();
                    //判断是否到达该执行的时间
                    long time = System.currentTimeMillis();
                    if (time >= task.getTime()) {
                        //执行
                        task.getRunnable().run();
                    } else {
                        long gap = task.getTime() - time;
                        //睡眠并且重新放入,睡眠的目的在于避免cpu做无用的消耗
                        synchronized (locker) {
                            locker.wait(gap);
                        }
                        //重新放入
                        queue.put(task);
                    }


                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
        });

3.这样确实对忙等问题进行了优化，但是有没有完全解决呢？事实上并没有，我们观察如下场景：

这时候我们如何改良呢？其实我们不难理解，其实这个问题产生的本质在于原子性问题：而原子性的解决方案是我们扩大synchronized范围即可。

    public MyTimer(){
        //创建线程
        Thread thread=new Thread(()->{
            //创建循环
            while(true) {
                //扩大synchronized范围，保证原子性
                synchronized (locker) {
                    //取出元素
                    try {
                        MyTask task = queue.take();
                        //判断是否到达该执行的时间
                        long time = System.currentTimeMillis();
                        if (time >= task.getTime()) {
                            //执行
                            task.getRunnable().run();
                        } else {
                            long gap = task.getTime() - time;
                            //睡眠并且重新放入,睡眠的目的在于避免cpu做无用的消耗
                            
                                locker.wait(gap);
                            
                            //重新放入
                            queue.put(task);
                        }


                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                }
            }
        });

而如果扩大了synchronized的范围之后，如果我们使用上图中的测试用例进行测试的话，我们却发现任务2无法执行，换句话说，在任务1后出现了死锁问题。

上面两张图片分析了死锁问题的产生原因，我们的本意是为了避免发生频率相对较小的原子性问题，却产生了问题相对较大的死锁问题，显然这样的解决方案是不合理的，所以我们必须在处理忙等问题上实现新的一种解决方案：通过创建一个新的后台线程，后台线程实现的任务也很简单：由于原子性所伴随的忙等问题是由于当一个新的任务加入阻塞队列之后出现了一次空的notifyAll()的问题，那么我们的下手点也变得明了起来了：通过增加notifyAll()的次数，折中处理出现的空notifyAll（）的问题。

//创建新的线程，折中解决原子性
        Thread backGround=new Thread(()->{
            synchronized (locker){
                locker.notifyAll();
            }
            //休眠
            try {
                TimeUnit.SECONDS.sleep(1);
                //设置为后台线程
                Thread.currentThread().setDaemon(true);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        backGround.start();

将这些问题解决之后，我们所手动实现的定时器已经是一个相对而言比较完善的定时器了，我们将完整的代码放在下面：

public class MyTimer {
    //创建锁对象
    private Object locker=new Object();
    //创建比较队列
    BlockingQueue<MyTask>queue=new PriorityBlockingQueue();
    //创建schedule方法,放入队列
    public void schedule(MyTask myTask) throws InterruptedException {

        queue.put(myTask);
        //解除睡眠
        synchronized (locker){
            locker.notifyAll();
        }
    }
    //创建构造器，实现队列元素的取出
    public MyTimer(){
        //创建线程
        Thread thread=new Thread(()->{
            //创建循环
            while(true) {
                //扩大synchronized范围，保证原子性
                synchronized (locker) {
                    //取出元素
                    try {
                        MyTask task = queue.take();
                        //判断是否到达该执行的时间
                        long time = System.currentTimeMillis();
                        if (time >= task.getTime()) {
                            //执行
                            task.getRunnable().run();
                        } else {
                            long gap = task.getTime() - time;
                            //睡眠并且重新放入,睡眠的目的在于避免cpu做无用的消耗

                                locker.wait(gap);

                            //重新放入
                            queue.put(task);
                        }


                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                }
            }
        });
        thread.start();
        //创建新的线程，折中解决原子性
        Thread backGround=new Thread(()->{
            synchronized (locker){
                locker.notifyAll();
            }
            //休眠
            try {
                TimeUnit.SECONDS.sleep(1);
                //设置为后台线程
                Thread.currentThread().setDaemon(true);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        backGround.start();
    }
}

public class MyTask implements Comparable<MyTask>{
    private long time;
    private Runnable runnable;
//创建get任务和时间

    public long getTime() {
        return time;
    }

    public Runnable getRunnable() {
        return runnable;
    }
//创建构造方法
    public MyTask(Runnable runnable,long time){
        //判断时间的可靠性
        if(time<0){
            throw  new RuntimeException("时间错误");
        }
        this.time=time+System.currentTimeMillis();
        this.runnable=runnable;
    }
    @Override
    public int compareTo(MyTask o) {
        //第一种方式
      //  return this.time-o.time;
        //为了防止越界，我们选择第二种比较方式
        if(this.time>o.time){
            return 1;
        }
        if(this.time==o.time){
            return  0;
        }
        else{
            return -1;
        }
    }
}

六子干侧开
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
C#中自定义高精度Timer定时器的实例教程
09-02
在实现高精度定时器时，还需要考虑线程安全问题。多线程环境下，多个线程同时访问和修改定时器的状态可能导致数据竞争。因此，需要使用锁（如Mutex、Semaphore或Monitor）或其他并发控制机制来确保线程安全。 总结...
C++：详解C++11 线程(一)：实现简易定时器的示例代码
C++ JAVA的专栏
03-10 1810
C++：详解C++11 线程(一)：实现简易定时器的示例代码
【多线程基础】 定时器Timer的使用及实现
热门推荐
书生-w的博客
03-25 2万+
定时器相当于一个任务管理器。有些任务可能现在执行， 有些任务可能过1个小时，甚至很久才会执行。定时器就是对这些任务进行管理监视， 如果一个任务执行时间到了，定时器就会将这个任务执行。 保证所有的任务都会在合适的时间执行。
定时任务最简单的3种实现方法
最新发布
weixin_64051447的博客
06-20 4803
定时任务在实际的开发中特别常见，比如电商平台 30 分钟后自动取消未支付的订单，以及凌晨的数据汇总和备份等，都需要借助定时任务来实现，那么我们本文就来看一下。
【多线程】在多线程环境下实现一个定时器
qq_54883034的博客
07-25 860
描述一个任务使用优先队列来组织若干个任务，并且这个优先队列要带有阻塞实现一个schedule()方法来注册任务到队列中创建一个扫描线程，这个扫描线程不停的获取到队首元素，并且判定时间是否到达，另外需要注意的是让MyTask2类能够试吃比较，以及注意解决这里的忙等问题httpshttpshttpshttpshttps。...
timer_create的简单使用
qq_39667609的博客
11-26 805
当时间到达时，发送一个信号。当时间到达时，创建一个线程。
QT在子线程中调用定时器
09-08
QT框架是C++中广泛使用的跨平台应用开发库，它提供了丰富的功能，包括GUI、网络、数据库连接等。在QT中，线程是处理并发任务的重要...理解这些要点后，你就可以在多线程环境中灵活地利用定时器来实现复杂的定时任务。
java实现多线程之定时器任务
08-31
Java中的定时器任务是通过`java.util.Timer`类来实现的，它允许我们在特定时间或按照特定周期执行任务。`Timer`类提供了调度任务的方法，而这些任务是通过`TimerTask`类来定义的。`TimerTask`是`Runnable`接口的子类...
我写的Linux版Timer定时器(源码),可在多线程间使用
12-16
在Linux操作系统中，由于内核并不直接提供一个与Qt中类似的多线程安全的定时器，因此在开发多线程程序时，如果需要在不同...对于学习Linux系统编程、多线程编程以及自定义定时器的实现原理，这是一个很好的参考案例。
linux线程实现定时器源码
02-24
在Linux系统中，线程实现定时器是一种常见的技术，它涉及到多线程编程、时间管理以及C语言编程。本文将深入探讨如何使用C语言在Linux环境下编写线程定时器的源码，同时会涵盖相关标签所涉及的关键概念。 首先，我们...
linux下定时器timer_create()的使用
modi000的博客
04-12 2595
转载：linux下定时器timer_create()的使用_Turbyun的博客-CSDN博客_linux定时器timer_create 一、采用新线程派驻的方式 （注： 编译时 需加上 -lrt） #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <signal.h> #include <time.h> #include <error.h> .
timer_create定时器
gdizcm的专栏
11-09 594
主要内容转载文章https://blog.csdn.net/sinat_36184075/article/details/80489402 头文件： #include <signal.h> #include <time.h> 函数声明： int timer_create(clockid_t clockid, struct sigevent * sevp, timer_t * timerid); 功能：创建一个POSIX标准的进程定时器 参数： @clockid 可选系...
线程中的定时器
weixin_51500673的博客
04-20 867
定时器是一种控制任务延时调用，或者周期调用的技术。 定时器的实现方式 方式一：Timer publicvoidschedule​(TimerTasktask, longdelay, longperiod)。 task:处理的任务 delay：延迟时间 perriod：周期时间 package com.itheima.d7_timer; import java.util.Timer; import java.util.TimerTask; public class TimerDe...
c#多线程Timer定时器设计，访问主线程控件
xianzhetime的博客
10-21 2202
使用c#System,Timers计时器进行事件循环，它启动了多线程操作，并启用了委托，不会导致界面卡死，还可以访问任何主线程控件。
实现多线程里面的定时器
muyou0507的博客
12-23 413
定时器的实现 了解一下
线程的定时器问题
qq_45726327的博客
04-01 1133
多线程的定时器是一种在多线程环境下实现定时任务的技术。它能够让多个线程在指定的时间点执行特定的任务，而不需要每个线程都自己实现一个定时器。使用多线程的定时器可以避免线程阻塞和任务调度的复杂性，提高代码的可读性和可维护性。在多线程的定时器中，一般通过一个定时器线程来维护所有的定时任务，该线程负责按照指定的时间间隔检查所有的任务，并在任务的执行时间点将任务放入一个线程池中，让线程池中的线程来执行任务。多线程的定时器可以通过Java内置的Timer类来实现，也可以使用第三方框架，如Quartz等。
[Java Web]定时器（Timer） 线程池
weixin_61567666的博客
05-09 872
使用 Timer // 使用定时器 public class UseTimer { public static void main(String[] args) { // 一个定时器 + n 个定时器要去执行的任务 Timer timer = new Timer(); // 闹钟 // 继承 TimerTask（抽象类） // 执行的是 task.run() 方法 TimerTask task = new Ti
java多线程（二） - Timer 源码阅读
Nyle
09-16 201
java多线程（二） - Timer 源码阅读在JDK5ScheduledThreadPoolExecutor 之前。使用Timer定时器使用Timer在调用shedulue TimerTask的时候，会把这个task放到一个队列里 private final TaskQueue queue = new TaskQueue();在Timer new出来的时候，会启动一个Thread 这个线程会循
pyqt主窗口调用多个同一自定义控件，启动自定义控件中的任务，任务中启动处理线程以及定时器
06-06
好的，我来解答您的问题。 首先，您需要在主窗口中导入自定义控件，可以使用以下语句： ```python ...这样，您就可以在主窗口中调用多个自定义控件，并启动自定义控件中的任务、处理线程和定时器了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

六子干侧开

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

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

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

打赏作者

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

抵扣说明：

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

余额充值