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

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

#### 文章目录 ####

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

## ?定时器是什么 ##

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

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

## ?Java标准库中的定时器 ##

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

代码示例：

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

import java.util.Timer;
    import java.util.TimerTask;
    
    public class TestDemo {
        
        public static void main(String[] args) {
        
            Timer timer = new Timer();
            System.out.println("程序启动!");
            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);
        }
    }

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

## ?模拟实现定时器 ##

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

### ?定时器的构成 ###

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

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

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

### ?第一步：MyStack类的建立 ###

包含两个属性

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

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

代码实现如下：

public class MyTask implements Comparable<MyTask> {
        
        private Runnable runnable;
        private  long time;
    
        public MyTask() {
        
            System.out.println(1);
        }
        public void tad() {
        
            System.out.println(2);
        }
        public MyTask(Runnable runnable, long time) {
        
            this.runnable = runnable;
            this.time = time;
        }
        public long gettime(MyTask) {
        
            return this.time;
        }
        //执行任务
        public void run() {
        
            runnable.run();
        }
        @Override
        public int compareTo(MyTask o) {
        
            return (int)(this.time - o.time);
        }
    }

### ?第二步：创建MyTimer类 ###

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

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

public class MyTimer {
        
        // 有一个阻塞优先级队列, 来保存任务.
        private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
    
        // 指定两个参数
        // 第一个参数是 任务 内容
        // 第二个参数是 任务 在多少毫秒之后执行. 形如 1000
        public void schedule(Runnable runnable, long after) {
        
            // 注意这里的时间上的换算
            MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
            queue.put(task);
        }
    }

*  由于我们输入的都是一个时间大小，所以我们需要进行处理一下，
 *  这里的System.currentTimeMillis()是获取当时的时间戳
 *  再加上所需要的时间大小即达到我们效果

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

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

private Thread t = null;
        public MyTimer() {
        
            t = new Thread() {
        
                @Override
                public void run() {
        
                    while (true) {
        
                        try {
        
                            // 取出队首元素, 检查看看队首元素任务是否到时间了.
                            // 如果时间没到, 就把任务塞回队列里去.
                            // 如果时间到了, 就把任务进行执行.
                            MyTask myTask = queue.take();
                            long curTime = System.currentTimeMillis();
                            if (curTime < myTask.getTime()) {
        
                                // 还没到点, 先不必执行
                                // 现在是 13:00, 取出来的任务是 14:00 执行
                                //塞回去
                                queue.put(myTask);
                            } else {
        
                                // 时间到了!! 执行任务!!
                                myTask.run();
                            }
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            };
            //启动线程
            t.start();
        }

### ?第三步：解决相关问题 ###

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

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

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

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

*  问题二：原子性问题

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

问题情况如下：

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

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

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

代码实现如下：

import java.util.concurrent.PriorityBlockingQueue;
    
    public class MyTimer {
        
        // 有一个阻塞优先级队列, 来保存任务.
        private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
        // 扫描线程
        private Thread t = null;
        private Object locker = new Object();
        public MyTimer() {
        
            t = new Thread() {
        
                @Override
                public void run() {
        
                    while (true) {
        
                        try {
        
                            // 取出队首元素, 检查看看队首元素任务是否到时间了.
                            // 如果时间没到, 就把任务塞回队列里去.
                            // 如果时间到了, 就把任务进行执行.
                            synchronized (locker) {
        
                                MyTask myTask = queue.take();
                                long curTime = System.currentTimeMillis();
                                if (curTime < myTask.getTime()) {
        
                                    // 还没到点, 先不必执行
                                    // 现在是 13:00, 取出来的任务是 14:00 执行
                                    queue.put(myTask);
                                    // 在 put 之后, 进行一个 wait
                                    locker.wait(myTask.getTime() - curTime);
                                } else {
        
                                    // 时间到了!! 执行任务!!
                                    myTask.run();
                                }
                            }
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            };
            t.start();
        }
        // 指定两个参数
        // 第一个参数是 任务 内容
        // 第二个参数是 任务 在多少毫秒之后执行. 形如 1000
        public void schedule(Runnable runnable, long after) {
        
            // 注意这里的时间上的换算
            MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
            queue.put(task);
            synchronized (locker) {
        
                locker.notify();
            }
        }
    }

## ?完整代码实现与测试 ##

计时器完整代码：

import java.util.concurrent.PriorityBlockingQueue;
    
    class MyTask implements Comparable<MyTask> {
        
        private Runnable runnable;
        private  long time;
    
        public MyTask() {
        
            System.out.println(1);
        }
        public void tad() {
        
            System.out.println(2);
        }
        public MyTask(Runnable runnable, long time) {
        
            this.runnable = runnable;
            this.time = time;
        }
        public long getTime() {
        
            return this.time;
        }
        //执行任务
        public void run() {
        
            runnable.run();
        }
        @Override
        public int compareTo(MyTask o) {
        
            return (int)(this.time - o.time);
        }
    }
    
    public class MyTimer {
        
        // 有一个阻塞优先级队列, 来保存任务.
        private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
        // 扫描线程
        private Thread t = null;
        private Object locker = new Object();
        public MyTimer() {
        
            t = new Thread() {
        
                @Override
                public void run() {
        
                    while (true) {
        
                        try {
        
                            // 取出队首元素, 检查看看队首元素任务是否到时间了.
                            // 如果时间没到, 就把任务塞回队列里去.
                            // 如果时间到了, 就把任务进行执行.
                            synchronized (locker) {
        
                                MyTask myTask = queue.take();
                                long curTime = System.currentTimeMillis();
                                if (curTime < myTask.getTime()) {
        
                                    // 还没到点, 先不必执行
                                    // 现在是 13:00, 取出来的任务是 14:00 执行
                                    queue.put(myTask);
                                    // 在 put 之后, 进行一个 wait
                                    locker.wait(myTask.getTime() - curTime);
                                } else {
        
                                    // 时间到了!! 执行任务!!
                                    myTask.run();
                                }
                            }
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            };
            t.start();
        }
        // 指定两个参数
        // 第一个参数是 任务 内容
        // 第二个参数是 任务 在多少毫秒之后执行. 形如 1000
        public void schedule(Runnable runnable, long after) {
        
            // 注意这里的时间上的换算
            MyTask task = new MyTask(runnable, System.currentTimeMillis() + after);
            queue.put(task);
            synchronized (locker) {
        
                locker.notify();
            }
        }
    }

测试代码如下

public class TestDemo2 {
        
        public static void main(String[] args) {
        
            MyTimer myTimer = new MyTimer();
            System.out.println("程序启动");
            myTimer.schedule(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("计时器3");
                }
            },3000);
            myTimer.schedule(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("计时器2");
                }
            },2000);
            myTimer.schedule(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("计时器1");
                }
            },1000);
        }
    }

测试结果如下：  
![在这里插入图片描述][da87dcc81b0343faabd9ab8d99ea7e07.png]

## ⭕总结 ##

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

[3676f1e05806441097c3303845bc8a81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/f9914096f0564350b45d5caead19944c.png
[d42d35f5accb43e9a437f6def0dc5730.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/a4d4a03888764292823c2ff7b48288ab.png
[30d67ded7a6740e3be2d4a0825ed2500.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/5c9941cecd344e4690a1ba2ae1efc35a.png
[da87dcc81b0343faabd9ab8d99ea7e07.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/14/307abc5e56354c9a8898cdb463b1a08f.png