【多线程】（四）定时器及其模拟实现

以你之姓@ 2023-10-13 17:33 24阅读 0赞

### 文章目录 ###

*  一、什么是定时器
 *  二、Java库中的定时器
 *   *  2.1 Timer 类
     *  2.2 使用案例
 *  三、定时器的模拟实现

--------------------

# 一、什么是定时器 #

定时器是一种用于**在指定的时间间隔或指定的时间点执行任务的工具**。它允许开发人员在程序中安排任务在未来的某个时间点执行，或者按照固定的时间间隔重复执行。

定时器通常用于需要定期执行某些操作的场景，例如**定时任务调度、定时数据备份、定时数据同步**等。它可以帮助开发人员实现按照预定时间执行任务的逻辑，而不需要手动计算时间和编写复杂的定时逻辑。

# 二、Java库中的定时器 #

## 2.1 Timer 类 ##

在Java中，定时器功能可以通过`java.util.Timer`类来实现。`Timer`类提供了一组方法，可以安排任务在指定的时间点执行，或按照固定的时间间隔重复执行。使用`Timer`类，开发人员可以创建一个定时器对象，然后通过调用`schedule`方法来安排任务执行。

下面是`Timer`类常用方法的Markdown表格表示：

<table> 
 <thead> 
  <tr> 
   <th align="left">方法名</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>void schedule(TimerTask task, Date time)</code></td> 
   <td align="left">在指定的时间点执行任务。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>void schedule(TimerTask task, Date firstTime, long period)</code></td> 
   <td align="left">在指定的时间点开始执行任务，并以指定的时间间隔重复执行。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>void schedule(TimerTask task, long delay)</code></td> 
   <td align="left">在指定的延迟时间后执行任务，只执行一次。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>void schedule(TimerTask task, long delay, long period)</code></td> 
   <td align="left">在指定的延迟时间后开始执行任务，并以指定的时间间隔重复执行。</td> 
  </tr> 
 </tbody> 
</table>

这些方法都是`Timer`类提供的重载方法，用于安排定时任务的执行。其中，`TimerTask`是一个抽象类（功能相当于`Runnable`），需要通过继承和实现其`run`方法来定义具体的任务逻辑。

注意，在使用`Timer`类时，需要注意任务的执行时间和时间间隔，以避免任务执行时间过长导致后续任务延迟执行或任务堆积。同时，还需要考虑线程安全和异常处理，以保证定时任务的可靠性和稳定性。

## 2.2 使用案例 ##

public class ThreadDemo {
        
    
        public static void main(String[] args) {
        
            Timer timer = new Timer();
    
            // TimerTask 就相当于 Runnable
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println("运行定时器任务3");
                }
            }, 3000);
    
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println("运行定时器任务2");
                }
            }, 2000);
    
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println("运行定时器任务1");
                }
            }, 1000);
    
        }
    }

这段代码演示了使用`Timer`类来安排多个定时任务的执行。

*  在这个示例中，首先创建了一个`Timer`对象。然后，通过`timer.schedule()`方法安排了三个定时任务，分别在不同的延迟时间后执行。
 *  每个定时任务都是一个`TimerTask`的匿名内部类对象，重写了`run()`方法来定义任务的逻辑。在`run()`方法中，分别输出不同的消息表示任务的执行。
 *  第一个定时任务将在程序启动后的1秒后执行，输出消息"运行定时器任务1"。第二个定时任务将在程序启动后的2秒后执行，输出消息"运行定时器任务2"。第三个定时任务将在程序启动后的3秒后执行，输出消息"运行定时器任务3"。

# 三、定时器的模拟实现 #

import java.util.concurrent.PriorityBlockingQueue;
    
    // 要执行的任务类
    class MyTask implements Comparable<MyTask> {
        
        // 任务内容
        private Runnable runnable;
        // 时间（毫秒）
        private long time;
    
        public MyTask(Runnable runnable, long time) {
        
            this.runnable = runnable;
            this.time = time;
        }
    
        // 获取当前任务的时间
        public long getTime() {
        
            return time;
        }
    
        // 执行时间
        public void run() {
        
            runnable.run();
        }
    
    
        @Override
        public int compareTo(MyTask o) {
        
            return (int) (this.time - o.time);
        }
    }
    
    // 模拟实现定时器
    class MyTimer {
        
        // 扫描线程
        private Thread thread = null;
    
        // 使用优先级阻塞队列来保存任务
        private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
    
        public MyTimer() {
        
            thread = new Thread(() -> {
        
                // 取出队首元素，检查队首元素是否到时间了，
                // 如果时间没到，就把任务放回队列
                // 否则就取出来执行
                while (true) {
        
                    try {
        
                        // 保证wait之后再执行put中的notify操作，
                        // 目的是防止因为线程的无序调度导致还没有执行wait的时候就notify了。
                        // 比如现在13点，当前任务14点执行，当执行完第58行代码时，当前线程被切走了，
                        // 然后插入了一个13点30执行的任务并执行了notify操作，而此时还没有wait
                        synchronized (this) {
        
                            MyTask task = queue.take();
                            long curTime = System.currentTimeMillis();
                            if (curTime < task.getTime()) {
        
                                // 还没到点，先不执行，将任务放回队列
                                queue.put(task);
    
                                // 然后使用 wait 进行等待，当新放入一个元素的时候就notify。目的是解决忙等问题。
                                // 不使用sleep的原因就是，中途可能放入一个更早的任务
                                this.wait(task.getTime() - curTime);
    
                            } else {
        
                                // 到点了，执行任务
                                task.run();
                            }
                        }
    
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
    
            thread.start();
        }
    
        /**
         * @param runnable 任务内容
         * @param after    在多少毫秒之后执行任务
         */
        public void schedule(Runnable runnable, long after) {
        
            MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
            queue.put(task);
            // 放入一个任务就通知
            synchronized (this) {
        
                this.notify();
            }
        }
    }

这段代码是一个简单的模拟实现定时器的示例。它包含了一个`MyTimer`类和一个`MyTask`类。

*  `MyTask`类表示要执行的任务，实现了`Comparable`接口用于在优先级队列中进行比较。它包含一个`runnable`属性表示任务内容，一个`time`属性表示任务的执行时间。在`MyTask`类中，定义了`getTime()`方法用于获取任务的执行时间，以及`run()`方法用于执行任务的具体逻辑。
 *  `MyTimer`类模拟实现了定时器的功能。它使用`PriorityBlockingQueue`作为优先级阻塞队列来保存任务。在`MyTimer`类的构造函数中，创建了一个扫描线程，该线程不断地从队列中取出任务进行处理。
 *  在扫描线程的循环中，首先使用`queue.take()`方法从队列中取出队首元素（最近的任务）。然后，获取当前时间，如果当前时间小于任务的执行时间，则将任务放回队列，并使用`wait()`方法进行等待。通过`wait()`方法，等待到任务的执行时间或有新任务插入队列时才被唤醒，目的是避免线程的忙等。
 *  如果当前时间大于等于任务的执行时间，说明任务到达执行时间，就执行该任务的`run()`方法。
 *  `MyTimer`类提供了一个`schedule()`方法，用于向定时器中添加任务。在`schedule()`方法中，根据传入的参数创建一个`MyTask`对象，并将其放入队列中。同时，通过`synchronized`关键字加锁，并使用`notify()`方法通知正在等待的扫描线程。
 *  通过创建`MyTimer`对象，可以使用`schedule()`方法来安排定时任务的执行。定时任务会按照指定的时间间隔被添加到队列中，并在到达执行时间时被执行。