【JavaEE初阶】 定时器详解与实现

心已赠人 2024-04-17 10:31 142阅读 0赞

文章目录

  • ?定时器是什么
  • ?Java标准库中的定时器
  • ?模拟实现定时器
    • ?定时器的构成
    • ?第一步：MyStack类的建立
    • ?第二步：创建MyTimer类
    • ?第三步：解决相关问题
  • ?完整代码实现与测试
  • ⭕总结

?定时器是什么

在这里插入图片描述
定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码

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

?Java标准库中的定时器

  • 标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .
  • schedule 包含两个参数.
  • 第一个参数指定即将要执行的任务代码,
  • 第二个参数指定多长时间之后执行 (单位为毫秒)

代码示例：

下面程序分别有一个定时器，设置了三个不同的时间

  1. import java.util.Timer;
  2. import java.util.TimerTask;
  4. public class TestDemo {
  6.     public static void main(String[] args) {
  8.         Timer timer = new Timer();
  9.         System.out.println("程序启动!");
  10.         timer.schedule(new TimerTask() {
  12.             @Override
  13.             public void run() {
  15.                 System.out.println("定时器3");
  16.             }
  17.         },3000);
  18.         timer.schedule(new TimerTask() {
  20.             @Override
  21.             public void run() {
  23.                 System.out.println("定时器2");
  24.             }
  25.         },2000);
  26.         timer.schedule(new TimerTask() {
  28.             @Override
  29.             public void run() {
  31.                 System.out.println("定时器1");
  32.             }
  33.         },1000);
  34.     }
  35. }

运行结果如下：
在这里插入图片描述
结果如我们所示，按照时间顺序进行打印

?模拟实现定时器

首先我们先来看一下定时器的构成

?定时器的构成

  1. 一个带优先级的阻塞队列

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

  2. 队列中的每个元素是一个 MyTask 对象.

  3. MyTask 中带有一个时间属性, 队首元素就是即将要执行的任务
  4. 同时有一个线程一直扫描队首元素, 看队首元素是否需要执行

?第一步：MyStack类的建立

包含两个属性

  • 包含一个 Runnable 对象
  • 一个 time(毫秒时间戳)

由于我们的MyTask类需要放入一个带优先级的阻塞队列中，所以我们需要MyTack可以比较，这里博主选择重写 Comparable 接口里的compareTo方法

代码实现如下：

  1. public class MyTask implements Comparable<MyTask> {
  3.     private Runnable runnable;
  4.     private  long time;
  6.     public MyTask() {
  8.         System.out.println(1);
  9.     }
  10.     public void tad() {
  12.         System.out.println(2);
  13.     }
  14.     public MyTask(Runnable runnable, long time) {
  16.         this.runnable = runnable;
  17.         this.time = time;
  18.     }
  19.     public long gettime(MyTask) {
  21.         return this.time;
  22.     }
  23.     //执行任务
  24.     public void run() {
  26.         runnable.run();
  27.     }
  28.     @Override
  29.     public int compareTo(MyTask o) {
  31.         return (int)(this.time - o.time);
  32.     }
  33. }

?第二步：创建MyTimer类

该类需要有一个带有优先级的阻塞队列

还需要有一个可schedule 方法用于我们来插入我们我们需要执行的任务

  1. public class MyTimer {
  3.     // 有一个阻塞优先级队列, 来保存任务.
  4.     private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
  6.     // 指定两个参数
  7.     // 第一个参数是 任务 内容
  8.     // 第二个参数是 任务 在多少毫秒之后执行. 形如 1000
  9.     public void schedule(Runnable runnable, long after) {
  11.         // 注意这里的时间上的换算
  12.         MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
  13.         queue.put(task);
  14.     }
  15. }
  • 由于我们输入的都是一个时间大小，所以我们需要进行处理一下，
  • 这里的System.currentTimeMillis()是获取当时的时间戳
  • 再加上所需要的时间大小即达到我们效果

其次还需要一个线程循环扫描

  • 该扫描我们需要做的是
  • 取出队首元素, 检查看看队首元素任务是否到时间了.
  • 如果时间没到, 就把任务塞回队列里去.

  • 如果时间到了, 就把任务进行执行.

    private Thread t = null;

    1. public MyTimer() {
    3.     t = new Thread() {
    5.         @Override
    6.         public void run() {
    8.             while (true) {
    10.                 try {
    12.                     // 取出队首元素, 检查看看队首元素任务是否到时间了.
    13.                     // 如果时间没到, 就把任务塞回队列里去.
    14.                     // 如果时间到了, 就把任务进行执行.
    15.                     MyTask myTask = queue.take();
    16.                     long curTime = System.currentTimeMillis();
    17.                     if (curTime < myTask.getTime()) {
    19.                         // 还没到点, 先不必执行
    20.                         // 现在是 13:00, 取出来的任务是 14:00 执行
    21.                         //塞回去
    22.                         queue.put(myTask);
    23.                     } else {
    25.                         // 时间到了!! 执行任务!!
    26.                         myTask.run();
    27.                     }
    28.                 } catch (InterruptedException e) {
    30.                     e.printStackTrace();
    31.                 }
    32.             }
    33.         }
    34.     };
    35.     //启动线程
    36.     t.start();
    37. }

?第三步：解决相关问题

  • 问题一：while (true) 转的太快了, 造成了无意义的 CPU 浪费.

比如第一个任务设定的是 1 min 之后执行某个逻辑. 但是这里的 while (true) 会导致每秒钟访问队首元素几万次.

解决办法：引入一个locker对象, 借助该对象的 wait / notify 来解决 while (true) 的忙等问题.

我们在循环扫描里：引入 wait, 等待一定的时间.并修改 MyTimer 的 schedule 方法, 每次有新任务到来的时候唤醒一下循环扫描线程. (因为新插入的任务可能是需要马上执行的)

  • 问题二：原子性问题

由于我们的出队列操作和判断语句不具有原子性

问题情况如下：

出队列操作拿到任务后，还没有进行判断

然后这时候有一个来了一个新任务
在这里插入图片描述
但是此时我们该任务还没有wait()操作，而且我们由于添加新元素，notify()操作已执行，这就导致后面的wait操作不会被唤醒，那么新来的任务就在相应时间来没有被执行

解决方法：将出队列操作与判断操作都加上锁

代码实现如下：

  1. import java.util.concurrent.PriorityBlockingQueue;
  3. public class MyTimer {
  5.     // 有一个阻塞优先级队列, 来保存任务.
  6.     private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
  7.     // 扫描线程
  8.     private Thread t = null;
  9.     private Object locker = new Object();
  10.     public MyTimer() {
  12.         t = new Thread() {
  14.             @Override
  15.             public void run() {
  17.                 while (true) {
  19.                     try {
  21.                         // 取出队首元素, 检查看看队首元素任务是否到时间了.
  22.                         // 如果时间没到, 就把任务塞回队列里去.
  23.                         // 如果时间到了, 就把任务进行执行.
  24.                         synchronized (locker) {
  26.                             MyTask myTask = queue.take();
  27.                             long curTime = System.currentTimeMillis();
  28.                             if (curTime < myTask.getTime()) {
  30.                                 // 还没到点, 先不必执行
  31.                                 // 现在是 13:00, 取出来的任务是 14:00 执行
  32.                                 queue.put(myTask);
  33.                                 // 在 put 之后, 进行一个 wait
  34.                                 locker.wait(myTask.getTime() - curTime);
  35.                             } else {
  37.                                 // 时间到了!! 执行任务!!
  38.                                 myTask.run();
  39.                             }
  40.                         }
  41.                     } catch (InterruptedException e) {
  43.                         e.printStackTrace();
  44.                     }
  45.                 }
  46.             }
  47.         };
  48.         t.start();
  49.     }
  50.     // 指定两个参数
  51.     // 第一个参数是 任务 内容
  52.     // 第二个参数是 任务 在多少毫秒之后执行. 形如 1000
  53.     public void schedule(Runnable runnable, long after) {
  55.         // 注意这里的时间上的换算
  56.         MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
  57.         queue.put(task);
  58.         synchronized (locker) {
  60.             locker.notify();
  61.         }
  62.     }
  63. }

?完整代码实现与测试

计时器完整代码：

  1. import java.util.concurrent.PriorityBlockingQueue;
  3. class MyTask implements Comparable<MyTask> {
  5.     private Runnable runnable;
  6.     private  long time;
  8.     public MyTask() {
  10.         System.out.println(1);
  11.     }
  12.     public void tad() {
  14.         System.out.println(2);
  15.     }
  16.     public MyTask(Runnable runnable, long time) {
  18.         this.runnable = runnable;
  19.         this.time = time;
  20.     }
  21.     public long getTime() {
  23.         return this.time;
  24.     }
  25.     //执行任务
  26.     public void run() {
  28.         runnable.run();
  29.     }
  30.     @Override
  31.     public int compareTo(MyTask o) {
  33.         return (int)(this.time - o.time);
  34.     }
  35. }
  37. public class MyTimer {
  39.     // 有一个阻塞优先级队列, 来保存任务.
  40.     private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
  41.     // 扫描线程
  42.     private Thread t = null;
  43.     private Object locker = new Object();
  44.     public MyTimer() {
  46.         t = new Thread() {
  48.             @Override
  49.             public void run() {
  51.                 while (true) {
  53.                     try {
  55.                         // 取出队首元素, 检查看看队首元素任务是否到时间了.
  56.                         // 如果时间没到, 就把任务塞回队列里去.
  57.                         // 如果时间到了, 就把任务进行执行.
  58.                         synchronized (locker) {
  60.                             MyTask myTask = queue.take();
  61.                             long curTime = System.currentTimeMillis();
  62.                             if (curTime < myTask.getTime()) {
  64.                                 // 还没到点, 先不必执行
  65.                                 // 现在是 13:00, 取出来的任务是 14:00 执行
  66.                                 queue.put(myTask);
  67.                                 // 在 put 之后, 进行一个 wait
  68.                                 locker.wait(myTask.getTime() - curTime);
  69.                             } else {
  71.                                 // 时间到了!! 执行任务!!
  72.                                 myTask.run();
  73.                             }
  74.                         }
  75.                     } catch (InterruptedException e) {
  77.                         e.printStackTrace();
  78.                     }
  79.                 }
  80.             }
  81.         };
  82.         t.start();
  83.     }
  84.     // 指定两个参数
  85.     // 第一个参数是 任务 内容
  86.     // 第二个参数是 任务 在多少毫秒之后执行. 形如 1000
  87.     public void schedule(Runnable runnable, long after) {
  89.         // 注意这里的时间上的换算
  90.         MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
  91.         queue.put(task);
  92.         synchronized (locker) {
  94.             locker.notify();
  95.         }
  96.     }
  97. }

测试代码如下

  1. public class TestDemo2 {
  3.     public static void main(String[] args) {
  5.         MyTimer myTimer = new MyTimer();
  6.         System.out.println("程序启动");
  7.         myTimer.schedule(new Runnable() {
  9.             @Override
  10.             public void run() {
  12.                 System.out.println("计时器3");
  13.             }
  14.         },3000);
  15.         myTimer.schedule(new Runnable() {
  17.             @Override
  18.             public void run() {
  20.                 System.out.println("计时器2");
  21.             }
  22.         },2000);
  23.         myTimer.schedule(new Runnable() {
  25.             @Override
  26.             public void run() {
  28.                 System.out.println("计时器1");
  29.             }
  30.         },1000);
  31.     }
  32. }

测试结果如下：
在这里插入图片描述

⭕总结

关于《【JavaEE初阶】 定时器详解与实现》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！

发表评论

表情：
评论列表 （有 0 条评论，142人围观）

还没有评论，来说两句吧...

相关阅读