【JavaEE初阶】第九节.多线程 (基础篇)定时器(案例三)

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档

前言

一、定时器概述、

二、定时器的实现 

2.1 Java标准库 定时器的使用

 2.2 自己模拟实现一个定时器

 2.3 对自己实现的定时器的进一步优化

2.3.1 为何需要再进行优化

2.3.2 如何进行进一步优化(一) 

2.3.3 如何进行进一步优化(二)

2.4 附上自己模拟实现定时器的代码

总结



前言

提示:这里可以添加本文要记录的大概内容:

继多线程的阻塞队列之后,我们来学习一下 第三个经典的案例 —— 定时器;

定时器,也是开发中的一个比较常用的基础组件;

定时器,就像闹钟一样,闹钟在达到一个设定的时间以后,就会发出响声来提醒;而定时器到了设定好的时间以后,就会执行某个指定好的代码;

一、定时器概述

定时器,又称 任务定时执行器;

即:到了一定的时间,就会去执行指定的任务;

在 Java标准库中,提供了一个带有定时器功能的 Timer类,Timer类 的核心方法是 schedule方法

schedule方法 包含了两个参数,第一个参数为 即将要执行的任务代码,第二个参数为 指定多长时间后执行地一个参数中的代码(单位是 毫秒)

如:

Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        System.out.println("hello");
   }
}, 3000);

二、定时器的实现 

2.1 Java标准库 定时器的使用

代码实现:

【JavaEE初阶】第九节.多线程 (基础篇)定时器(案例三)_第1张图片

运行结果:

在观察运行结果之后,就会提出两个小问题:

问题一:程序执行完之后,为啥没有结束呢?

实现定时器,背后涉及到了多线程,Timer 里面有线程,这个线程的运行阻止了 进程的退出;


问题二:那为什么不直接使用 sleep 呢,还专门搞了一个定时器?

使用 sleep 是把当前线程给阻塞了;

换句话说,sleep 的时间里,啥也干不了,只能干等着;但是使用定时器,之前的线程该干啥干啥;

我们可以来证实一下,加一些代码并且观察运行结果:

【JavaEE初阶】第九节.多线程 (基础篇)定时器(案例三)_第2张图片

运行结果:

 

我们从中可以看出,在 定时器定时的那段时间里,线程是在继续干活的,仍然在打印出 main

如果使用 sleep,那么这段时间就只能干等了

所以,平常使用的还是定时器较多

 
  

 2.2 自己模拟实现一个定时器

在模拟实现定时器之前,我们应该要思考清楚,一个定时器里面应该要有什么

首先,我们要清楚,一个 Timer 内部其实是可以加入很多很多任务的;

其次,Timer 里的每一个任务都要通过一定的方式描述出来(描述任务的过程 其实就相当于自己定义 TimerTask)

最后,还需要有一个线程,通过这个线程来扫描定时器 内部的任务,并执行其中时间到了的任务;

虽然当前的任务有很多,但是它们的执行顺序是一定的:按照时间顺序先后来执行;

此处 可以使用 优先级队列来执行,使用优先级队列可以非常高效的 找到当前时间最小的任务(首先要执行的任务)


代码实现:

package thread;
 
import java.util.PriorityQueue;
import java.util.concurrent.PriorityBlockingQueue;
 
//通过这个类来描述一个任务
class MyTask implements Comparable {
    //获取具体任务
    private Runnable command;
    //执行任务时的时间戳
    private long time;
    //构造方法
    public MyTask (Runnable command,long after) {
        this.command = command;
        //我们希望知道完整的时间戳(几点几分几秒之后执行),所以用 当前系统时间戳+多长时间后执行 来表示
        //此处记录的是绝对时间戳,不是 "多长时间之后执行"
        this.time = System.currentTimeMillis() + after;
    }
    //执行任务的方法,直接在内部调用 Runnable 的 run 即可
    public void run() {
        command.run();
    }
 
    //获取执行时间
    public long getTime() {
        return time;
    }
 
    @Override
    public int compareTo(MyTask o) {
        //希望 时间小的在前面,时间大的在后面
        return (int) (this.time - o.time);
    }
}
//自己创建的定时器类
class MyTimer {
    //使用 优先级队列的数据结构 来保存若干个任务
    //但是调用 schedule 的时候,可能是多个线程调用,并不一定是单线程调用(比如说可以定多个闹钟)
    //所以使用 的队列应该是 带有优先级的阻塞队列 PriorityBlockingQueue
    private PriorityBlockingQueue queue = new PriorityBlockingQueue<>();
    //command 表示要执行的任务是啥,after 表示多长时间之后来执行这个任务
    public void schedule(Runnable command,long after) {
        MyTask myTask = new MyTask(command,after);
        queue.put(myTask);
    }
 
    public MyTimer() {
        //在这里启动一个线程,来完成执行任务的工作
        //尤其是每次出队列,来执行时间最短的任务
        Thread t = new Thread(() -> {
            while (true) {
                //循环过程中,不断的尝试从队列中获取到队首元素
                //判定队首元素当前的时间是否就绪,时间有没有到点,如果就绪就执行,如果不就绪就不执行
                try {
                    MyTask myTask = queue.take();
                    long curTime = System.currentTimeMillis();
                    if (myTask.getTime() > curTime) {
                        //时间还没有到,塞回到队列中
                        queue.put(myTask);
                    }else{
                        //时间到了,直接执行任务
                        myTask.run();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

上面就是定时器的模拟实现代码,现在就需要我们来小小测试一下效果:

//测试代码
public class Demo24 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
 
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("2222");
            }
        },4000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("1111");
            }
        },2000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("3333");
            }
        },6000);
    }
}

运行结果: 

 2.3 对自己实现的定时器的进一步优化

2.3.1 为何需要再进行优化

这个线程的执行,还是有一定的缺陷的:

如果队列为空的话,那么的确在调用 take 的时候,在阻塞 没有什么太大的问题

如果队列不为空的话,那么 它会执行下面的逻辑:

取出任务
比较时间
如果时间未到,就会插入任务回队列
但是,当插入任务回队列的时候 且时间未到,就会再次调用 myTask,进入循环

但是,由于队列不为空 且时间未到,那么 又是调用,......

这样的后果,就是 如果队列不为空的话,且如果没有到时间,那么 就会产生大量的循环

这就相当于,CPU 在不断的进行 "空转",但是 又没有实质性的任务再执行,相当于在 "盲等"

2.3.2 如何进行进一步优化(一) 

我们希望,当我们把任务塞回队列之后,不应该让它立刻循环下一次,应该让线程等一会儿再进入循环;


如果引入了 sleep方法,看起来是会让线程不盲等,但是会引入新的问题;

举个例子,比如说,定了一个闹钟,想要下午两点和同学一起出去看电影;看了一下时间,现在才是 10:50,于是 sleep 了一个小时,到了 11:50;再看了一下时间,于是又 sleep 了一个小时 ......

这时候,你突然想起还有一个很紧急的事情没有做 —— 做核酸,在 12:00 之前帮助做核酸的志愿者就要走了;

但是,在 11:50 ~ 12:50 这段时间中,你仍然在 sleep,就无法在执行这个任务;

直到 sleep 结束,这个 "做核酸" 的任务才会被执行(于是,你又要等到下个时间段在去做了);


所以说,我们需要想想其它的办法

虽然 sleep 不行,但是 wait 可以,相比于 sleep 来说,wait 是可以被提前唤醒的!!!

如果是能够提前唤醒,就完全可以再插入新任务的时候,把这里的等待给唤醒,再去执行新的任务;

(

于是又 sleep 了一个小时 ......

这时候,你突然想起还有一个很紧急的事情没有做 —— 做核酸,在 12:00 之前帮助做核酸的志愿者就要走了;

但是,在 11:50 ~ 12:50 这段时间中,你仍然在 sleep,就无法在执行这个任务;)就可以避免这种情况的发生!!!)

代码实现:

  

2.3.3 如何进行进一步优化(二)

经过上述的优化,已经差不多了,只剩下最后一个小小的问题了


有这样一种情况,假设当前的时间是 10:00,此时 取出的队首元素是 11:00 要执行的任务,此时 时间还没有到,于是 就把这个任务塞回到队列中;

接着 就需要等待 1h,但是,我们知道,多线程执行两个线程的顺序是不确定的,于是 在 put 之后,wait 之前,可能会有另外的新任务到达了,新的任务是在 10:30 运行;

当我们把 新的任务 插入之后,进行了 notify;

但是,由于 另外一个线程还没有 wait,所以这个 notify 就相当于空打了一炮;

于是,回到了wait方法继续执行,就等待了的是 1h,而不是等待了的是 30min;


 之所以出现这个问题,主要是出现了线程调度的问题,因此需要把锁的范围扩大一点就可以了

 注意:取元素、判断时间、put、wait 应该视为原子操作,如果在其中间插入任务,都可能会出现风险的;


当然,如果直接放大锁的范围的话,由于后面的 take 会让线程造成死锁的问题(因为在初始情况下 队列可能是空着的),就会让线程阻塞 ;

所以还需要一个判断条件:

2.4 附上自己模拟实现定时器的代码

package thread;
 
import java.util.PriorityQueue;
import java.util.concurrent.PriorityBlockingQueue;
 
//通过这个类来描述一个任务
class MyTask implements Comparable {
    //获取具体任务
    private Runnable command;
    //执行任务时的时间戳
    private long time;
    //构造方法
    public MyTask (Runnable command,long after) {
        this.command = command;
        //我们希望知道完整的时间戳(几点几分几秒之后执行),所以用 当前系统时间戳+多长时间后执行 来表示
        //此处记录的是绝对时间戳,不是 "多长时间之后执行"
        this.time = System.currentTimeMillis() + after;
    }
    //执行任务的方法,直接在内部调用 Runnable 的 run 即可
    public void run() {
        command.run();
    }
 
    //获取执行时间
    public long getTime() {
        return time;
    }
 
    @Override
    public int compareTo(MyTask o) {
        //希望 时间小的在前面,时间大的在后面
        return (int) (this.time - o.time);
    }
}
//自己创建的定时器类
class MyTimer {
    //这个是用来阻塞等待的锁对象
    private Object locker = new Object();
    //使用 优先级队列的数据结构 来保存若干个任务
    //但是调用 schedule 的时候,可能是多个线程调用,并不一定是单线程调用(比如说可以定多个闹钟)
    //所以使用 的队列应该是 带有优先级的阻塞队列 PriorityBlockingQueue
    private PriorityBlockingQueue queue = new PriorityBlockingQueue<>();
    //command 表示要执行的任务是啥,after 表示多长时间之后来执行这个任务
    public void schedule(Runnable command,long after) {
        MyTask myTask = new MyTask(command,after);
        //唤醒
        synchronized (locker) {
            queue.put(myTask);
            locker.notify();
        }
    }
 
    public MyTimer() {
        //在这里启动一个线程,来完成执行任务的工作
        //尤其是每次出队列,来执行时间最短的任务
        Thread t = new Thread(() -> {
            while (true) {
                //循环过程中,不断的尝试从队列中获取到队首元素
                //判定队首元素当前的时间是否就绪,时间有没有到点,如果就绪就执行,如果不就绪就不执行
                try {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            locker.wait();
                        }
                        MyTask myTask = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (myTask.getTime() > curTime) {
                            //时间还没有到,塞回到队列中
                            queue.put(myTask);
                            //比如说,下午两点有新任务,现在 是十一点,那么 一减就可以得出 需要等待 三个小时就可以了
                            locker.wait(myTask.getTime() - curTime);
                        }else{
                            //时间到了,直接执行任务
                            myTask.run();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}
public class Demo24 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
 
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("2222");
            }
        },4000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("1111");
            }
        },2000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("3333");
            }
        },6000);
    }
}
 
 
 
 

好了,关于多线程的第三个案例 —— 定时器就介绍到这里了; 

总结

今天就介绍到这里了,我们下一节再见!!!!!!

【JavaEE初阶】第九节.多线程 (基础篇)定时器(案例三)_第3张图片

你可能感兴趣的:(JavaEE初阶,开发语言,java,javaee,多线程)