定时器--JAVA

定时器是软件开发中的一个重要组件，类似于一个"闹钟"当达到一个设定的时间之后,就执行某个指定好的代码(任务)。

Timer

JAVA标准库中已经为我们实现了一个定时器，我们直接new就行了。

Timer timer = new Timer();

Timer类中最重要的一个方法就是schedule()，这个方法用于设置定时器待执行的任务和执行任务的时间。

  1. public static void main(String[] args) {
  2.     Timer timer = new Timer();
  3.     //在3秒后打印3000
  4.     timer.schedule(new TimerTask() {
  5.         @Override
  6.         public void run() {
  7.             System.out.println("3000");
  8.         }
  9.     }, 3000);
  10.     //在2秒后打印2000
  11.     timer.schedule(new TimerTask() {
  12.         @Override
  13.         public void run() {
  14.             System.out.println("2000");
  15.         }
  16.     }, 2000);
  17.     //在1秒后打印1000
  18.     timer.schedule(new TimerTask() {
  19.         @Override
  20.         public void run() {
  21.             System.out.println("1000");
  22.         }
  23.     }, 1000);
  24.     
  25.     System.out.println("OK");
  26. }

可以发现在代码执行完毕后程序并没有结束，这是因为虽然主线程结束了但是Timer类中的线程在阻止程序结束，它们还在等待新的任务进来被执行。

为了可以更好的理解定时器的原理，下面进行简单的模拟实现。

模拟实现

首先我们需要先创建一个MyTimerTask类，该类主要用来保存待执行的任务，和执行该任务的时间点。

  1. class MyTimerTask {
  2.     public Runnable runnable;
  3.     //存储绝对时间，后期直接和当前时间比较大小就行
  4.     public long time;
  5.  
  6.     public MyTimerTask(Runnable runnable, long time){
  7.         this.runnable = runnable;
  8.         this.time = time + System.currentTimeMillis();
  9.     }
  10. }

接着写我们的定时器类MyTimer。首先我们应该先选择一种数据结构来存储所有的MyTimerTask，这里我推荐使用优先级队列，也就是堆。因为如果使用数组或链表来存储就需要你不断地遍历该数组/链表，而使用优先级队列就可以只检查队首元素是否到执行时间。

  1. public class MyTimer {
  2.     private final PriorityQueue priorityQueue = new PriorityQueue<>();
  3. }

因为我们使用了优先级队列所以我们需要让MyTimerTask类可以进行比较。

  1. class MyTimerTask implements Comparable{
  2.     ……
  3.     @Override
  4.     public int compareTo(MyTimerTask o) {
  5.         return (int) (this.time-o.time);
  6.     }
  7. }

接着我们需要实现一个schedule方法可以接收定时任务和时间，因为是多线程代码所以我们还应该加一个属性用来充当锁对象。

  1. public class MyTimer {
  2.     private final PriorityQueue priorityQueue = new PriorityQueue<>();
  3.     private Object lock = new Object();
  4.  
  5.     public void schedule(Runnable runnable, long time) {
  6.         synchronized (lock) {
  7.             priorityQueue.add(new MyTimerTask(runnable, time));
  8.         }
  9.     }
  10. }

此时我们还需要一个自动检查队列的线程，而且该线程并不需要程序员来启动和创建，所以我们可以将它写在构造方法中。

  1. public MyTimer() {
  2.     Thread t = new Thread(()->{
  3.         while(true) {
  4.             synchronized (lock) {
  5.                 if (priorityQueue.isEmpty()) {
  6.                     //堆为空           
  7.                 }
  8.                 MyTimerTask myTimerTask = priorityQueue.peek();
  9.                 if (myTimerTask.time <= System.currentTimeMillis()) {
  10.                     //执行当前任务
  11.                     myTimerTask.runnable.run();
  12.                     //将当前任务移除
  13.                     priorityQueue.poll();
  14.                 }else {
  15.                     //时间没到
  16.                 }
  17.             };
  18.         }
  19.     });
  20.     t.start();
  21. }

此处我们可以用阻塞队列的思想，当堆为空或者执行时间没到就使用wait()进行等待。有人添加任务时就使用notify()进行唤醒线程。

  1. public class MyTimer {
  2.     private final PriorityQueue priorityQueue = new PriorityQueue<>();
  3.     private Object lock = new Object();
  4.  
  5.     public void schedule(Runnable runnable, long time) {
  6.         synchronized (lock) {
  7.             priorityQueue.add(new MyTimerTask(runnable, time));
  8.             lock.notify();
  9.         }
  10.     }
  11.  
  12.     public MyTimer() {
  13.         Thread t = new Thread(()->{
  14.             while(true) {
  15.                 synchronized (lock) {
  16.                     if (priorityQueue.isEmpty()) {
  17.                         //如果堆为空就阻塞等待
  18.                         try {
  19.                             lock.wait();
  20.                         } catch (InterruptedException e) {
  21.                             throw new RuntimeException(e);
  22.                         }
  23.                     }
  24.                     MyTimerTask myTimerTask = priorityQueue.peek();
  25.                     if (myTimerTask.time <= System.currentTimeMillis()) {
  26.                         //执行当前任务
  27.                         myTimerTask.runnable.run();
  28.                         priorityQueue.poll();
  29.                     }else {
  30.                         //时间没到就阻塞等待
  31.                         try {
  32.                             lock.wait(myTimerTask.time-System.currentTimeMillis());
  33.                         } catch (InterruptedException e) {
  34.                             throw new RuntimeException(e);
  35.                         }
  36.                     }
  37.                 };
  38.             }
  39.         });
  40.         t.start();
  41.     }
  42. }

简单测试

  1. public static void main(String[] args) {
  2.     MyTimer timer = new MyTimer();
  3.     //在3秒后打印3000
  4.     timer.schedule(()->{
  5.             System.out.println("3000");
  6.     }, 3000);
  7.     //在2秒后打印2000
  8.     timer.schedule(()->{
  9.             System.out.println("2000");
  10.     }, 2000);
  11.     //在1秒后打印1000
  12.     timer.schedule(()->{
  13.             System.out.println("1000");
  14.     }, 1000);
  15.  
  16.     System.out.println("OK");
  17. }

完整代码

  1. import java.util.PriorityQueue;
  2.  
  3. class MyTimerTask implements Comparable{
  4.     public Runnable runnable;
  5.     //存储绝对时间，后期直接和当前时间比较大小就行
  6.     public long time;
  7.  
  8.     public MyTimerTask(Runnable runnable, long time){
  9.         this.runnable = runnable;
  10.         this.time = time + System.currentTimeMillis();
  11.     }
  12.  
  13.     @Override
  14.     public int compareTo(MyTimerTask o) {
  15.         return (int) (this.time-o.time);
  16.     }
  17. }
  18.  
  19. public class MyTimer {
  20.     private final PriorityQueue priorityQueue = new PriorityQueue<>();
  21.     private Object lock = new Object();
  22.  
  23.     public void schedule(Runnable runnable, long time) {
  24.         synchronized (lock) {
  25.             priorityQueue.add(new MyTimerTask(runnable, time));
  26.             lock.notify();
  27.         }
  28.     }
  29.  
  30.     public MyTimer() {
  31.         Thread t = new Thread(()->{
  32.             while(true) {
  33.                 synchronized (lock) {
  34.                     if (priorityQueue.isEmpty()) {
  35.                         //如果堆为空就阻塞等待
  36.                         try {
  37.                             lock.wait();
  38.                         } catch (InterruptedException e) {
  39.                             throw new RuntimeException(e);
  40.                         }
  41.                     }
  42.                     MyTimerTask myTimerTask = priorityQueue.peek();
  43.                     if (myTimerTask.time <= System.currentTimeMillis()) {
  44.                         //执行当前任务
  45.                         myTimerTask.runnable.run();
  46.                         priorityQueue.poll();
  47.                     }else {
  48.                         //时间没到就阻塞等待
  49.                         try {
  50.                             lock.wait(myTimerTask.time-System.currentTimeMillis());
  51.                         } catch (InterruptedException e) {
  52.                             throw new RuntimeException(e);
  53.                         }
  54.                     }
  55.                 };
  56.             }
  57.         });
  58.         t.start();
  59.     }
  60. }

注：本文转载自blog.csdn.net的《嗯》的文章"https://blog.csdn.net/2302_76339343/article/details/135511145"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！