[06]从零开始的JAVAEE-定时器

最新推荐文章于 2024-09-28 13:02:12 发布

不卷啊

最新推荐文章于 2024-09-28 13:02:12 发布

阅读量84

点赞数 5

分类专栏： JAVAEE 文章标签： java-ee java 数据结构

本文链接：https://blog.csdn.net/Lecture_max/article/details/130981088

版权

JAVAEE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一、什么是定时器

定时器相当于一个闹钟，可以设定一个时间，当时间到了就可以执行一段指定代码

标准库中提供的定时器

Timer：在java.util包下

定时器Timer中的方法

重点：schdule()方法

schedule(TimerTask task, long delay)

TimerTask:本质上是一个实现了Runnable接口的类，在这里表示一个要执行的任务
delay：等待的秒数，单位为ms

定时器的使用

    public static void main(String[] args) {
        Timer Timer = new Timer();//实例化
        //任务1，3s后执行
        Timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("1");
            }
        },3000);

        //任务2，2s后执行
        Timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("2");
            }
        },2000);

        //任务3，1s后执行
        Timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("3");
            }
        },1000);

        //任务4，立刻执行
        Timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("0");
            }
        },0);
    }

这段代码中，使用schedule方法依次添加五个任务，执行时间为3s后，2s后，1s后，立刻执行。下面来看运行结果

二、代码模拟实现定时器

在定时器的内部管理的不仅仅是一个任务，而是一堆任务，但是虽然任务有很多，却不需要创建很多线程去排序执行，只需要有一组工作线程，每一次都找到这些任务中最先到达时间的任务，依次去执行它们即可。

那么如何去找到这些最先到达时间的任务呢-答案显而易见，在JAVA标准库中就可以直接用到的数据结构：优先级阻塞队列（PriorityBlockingQueue）

优先级阻塞队列

优先级阻塞队列是JAVA库中自带的一个数据结构，它既可以有阻塞队列的阻塞功能，也可以根据优先级自动排序，且本身是数据安全的，是实现定时器的核心数据结构。

分析

要使用阻塞队列实现一个定时器，那么有一个问题，这个队列中应该存放什么样的元素，通过分析原生的Timer可以知道，传入定时器的元素为

一个TimeTask的类，实现Runnable接口。
一串表示时间的变量，由于这个变量传入定时器中表示的是指定时间后执行任务，所以这个变量的时间应该是当前时间戳+传入时间。

为了实现这个定时器中的任务时间比较，还需要实现Comparable接口。

可以创建一个类：

class MyTask implements Comparable<MyTask>{
    public Runnable runnable;//Runnable接口类型的变量

    public long time;//这里是绝对的时间戳，比如传入3000，为了方便判断，实际的值应该是当前时间戳+3000，在构造方法那里赋值

    //构造方法
    public MyTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        //为了方便判断，实际的值应该是当前时间戳+传入时间
        this.time = System.currentTimeMillis()+delay;
    }


    @Override
    public int compareTo(MyTask o) {
        return (int)(this.time-o.time);
    }
}

这里的time变量在构造方法中，给其赋值为传入时间+当前时间。

解决完放入优先级阻塞队列的元素之后，可以开始构建定时器，我们重点来实现Timer中的schdule方法

class MyTimer{
        PriorityBlockingQueue<MyTask> priorityBlockingQueue = new PriorityBlockingQueue<>();//优先级阻塞队列
    public void schedule(Runnable runnable,long delay){
        MyTask myTask = new MyTask(runnable,delay);
        priorityBlockingQueue.put(myTask);
    }
}

在schdule方法中，通过实例化myTask类然后通过put方法放入定时器中即可。

现在基本框架准备完毕，开始实现定时器的具体工作流程，首先创建一个工作线程，线程中的工作流程是这样的：

1.一直循环从队列中获取元素
2.获取当前系统时间
3.比较当前时间和取出的元素的要执行时间，如果可以执行，则执行这个元素中的run方法，如果不可以执行，放回到阻塞队列中

class MyTimer{
        PriorityBlockingQueue<MyTask> priorityBlockingQueue = new PriorityBlockingQueue<>();//优先级阻塞队列
    public void schedule(Runnable runnable,long delay){
        MyTask myTask = new MyTask(runnable,delay);
        priorityBlockingQueue.put(myTask);
    }

    public MyTimer() {
        Thread t = new Thread(()->{
            while (true){
                    try {
                        //1.从阻塞队列中拿元素
                        MyTask task = priorityBlockingQueue.take();
                        //2.获取当前系统时间
                        long delay = System.currentTimeMillis();
                        //3.比较一下要执行的时间和当前系统时间
                        if(task.time <= delay){
                            //可以执行了
                            task.runnable.run();
                        }else {
                            //塞回去
                            priorityBlockingQueue.put(task);
                            locker.wait(task.time-delay);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
        });
        t.start();
    }
}

至此一个基本的逻辑完毕，但还有一个非常关键的问题没有解决

忙等：在这段代码中，会出现大量的重复的无意义的取出/放回的操作。例如加入一个任务，2:30分上课，现在是2:00，那么这30分钟的时间内，线程会一直对队列进行取出元素-比较时间-放回元素的操作

解决方法：wait()，只需要在第一次取出元素-比较时间过后，看一下当前时间和要执行的时间的时间差，并将这个时间差作为参数传给wait让这个线程等待指定时间后在唤醒即可，注意：

等待需要搭配锁使用。
在安排新的任务加入阻塞队列中，要使用notify唤醒队列，防止插入了一个更早执行的任务却没有执行到

class MyTimer{
        PriorityBlockingQueue<MyTask> priorityBlockingQueue = new PriorityBlockingQueue<>();//优先级阻塞队列
    Object locker = new Object();//创建一个锁对象搭配后面的wait来使用
    public void schedule(Runnable runnable,long delay){
        MyTask myTask = new MyTask(runnable,delay);
        priorityBlockingQueue.put(myTask);
        synchronized (locker) {
            locker.notify();
        }
    }

    public MyTimer() {
        Thread t = new Thread(()->{
            while (true){
                synchronized (locker) {
                    try {
                        //1.从阻塞队列中拿元素
                        MyTask task = priorityBlockingQueue.take();
                        //2.获取当前系统时间
                        long delay = System.currentTimeMillis();
                        //3.比较一下要执行的时间和当前系统时间
                        if(task.time <= delay){
                            //可以执行了
                            task.runnable.run();
                        }else {
                            //塞回去
                            priorityBlockingQueue.put(task);
                            locker.wait(task.time-delay);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        
        t.start();
    }
}

一个值得思考的问题：

为什么这段代码中将取元素-比较时间-等待一起锁起来了，而不是只将需要用到锁的等待wait上锁呢，如果改为后者，会有怎样的情况？

解：

完整代码：

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.PriorityBlockingQueue;

//通过优先级阻塞队列构造定时器

//我的任务
class MyTask implements Comparable<MyTask>{
    public Runnable runnable;//Runnable接口类型的变量

    public long time;//这里是绝对的时间戳，比如传入3000，为了方便判断，实际的值应该是当前时间戳+3000，在构造方法那里赋值

    public MyTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        //为了方便判断，实际的值应该是当前时间戳+传入时间
        this.time = System.currentTimeMillis()+delay;
    }

    @Override
    public int compareTo(MyTask o) {
        return (int)(this.time-o.time);
    }
}

class MyTimer{
        PriorityBlockingQueue<MyTask> priorityBlockingQueue = new PriorityBlockingQueue<>();//优先级阻塞队列
    Object locker = new Object();//创建一个锁对象搭配后面的wait来使用
    public void schedule(Runnable runnable,long delay){
        MyTask myTask = new MyTask(runnable,delay);
        priorityBlockingQueue.put(myTask);
        synchronized (locker) {
            locker.notify();
        }
    }

    public MyTimer() {
        Thread t = new Thread(()->{
            while (true){
                synchronized (locker) {
                    try {
                        //1.从阻塞队列中拿元素
                        MyTask task = priorityBlockingQueue.take();
                        //2.获取当前系统时间
                        long delay = System.currentTimeMillis();
                        //3.比较一下要执行的时间和当前系统时间
                        if(task.time <= delay){
                            //可以执行了
                            task.runnable.run();
                        }else {
                            //塞回去
                            priorityBlockingQueue.put(task);
                            locker.wait(task.time-delay);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });


        t.start();
    }
}