JavaEE(系列10) -- 多线程案例3(定时器)

哈士奇的奥利奥

已于 2023-05-23 10:51:48 修改

阅读量291

点赞数

分类专栏： JavaEE 文章标签： java-ee java 开发语言

于 2023-05-23 10:48:49 首次发布

本文链接：https://blog.csdn.net/weixin_46114074/article/details/130820491

版权

JavaEE 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1. 定时器

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

2. 标准库中的定时器

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

使用步骤:

1. 实例化Timer对象

2.调用timer.schedule("任务",执行时间)

public class timerTest {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello4");
            }
        },4000);

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

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello2");
            }
        },2000);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello1");
            }
        },1000);
        System.out.println("hello");
    }
}

运行结果:先打印主进程的hello,后面陆续按照指定的时间进行打印每个线程的内容

3. 实现定时器

定时器的构成

一个带优先级的阻塞队列
队列中的每个元素都是一个Task对象
Task 中带有一个时间属性, 队首元素就是即将执行的任务
同时有一个 worker 线程一直扫描队首元素, 看队首元素是否需要执行

为什么使用带有优先级的堵塞队列?

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

3.1 创建带优先级的阻塞队列

3.2 创建MyTask类

队列中的每个元素都是一个Task对象,创建Mytask类,用来描述要执行的任务,以及执行的时间.(用于传入堵塞队列)

此处需要注意:

我们需要将Mytask类实现Comparable接口,根据执行的时间进行比较. 这样才能传入带有优先级的堵塞队列.

最终MyTask类代码为:

class MyTask implements Comparable<MyTask>{
    public Runnable runnable;
    public long time;

    public MyTask(Runnable runnable, long delay){
        // 取当前时刻的时间戳 + delay = 当前该任务实际执行的时间戳
        this.time = System.currentTimeMillis() + delay;
        this.runnable = runnable;
    }


    @Override
    public int compareTo(MyTask o) {
        //每次取出的是时间最小的元素
        return (int)(this.time -o.time);
    }
}

3.3 构建schedule方法

通过schedule方法往队列中插入Task对象

3.4 构建timer类中的线程

Timer 类中存在一个 worke 线程, 一直不停的扫描队首元素, 看看是否能执行这个任务.

此线程的实现思路

1. 线程要执行在队列中不断地取出任务 queue.take();
2.取出任务要进行比较当前系统时间与任务执行时间
3.如果任务执行时间小于当前系统时间,就说明要执行任务了.调用 myTask.runnable.run();
4.如果当前取出的任务执行时间大于当前系统时间,就说明任务还没有到执行时间,将任务推送到队列中.同时进入堵塞等待
5. 在schedule方法中,往优先级队列推送任务之后,同时加一个notify方法,用来唤醒此时正在堵塞的线程,使得堵塞等待解除,重新取队首任务进行比较时间.

加wait notify的好处,就是work线程不需要一直进行取队首元素,这样会消耗系统资源,造成没必要的浪费,只需要等待堵塞当前距离执行任务的时间差就可以,当有新的任务添加进来的时候接触堵塞,重新进行计算时间差,再决定是否进行执行任务,还是进入堵塞状态.

public class MyTimer {
    private final PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
    // 创建一个锁对象
    private final Object locker = new Object();
    public MyTimer(){
        //1.创建一个线程
        Thread work = new Thread(()->{
           while (true){
               try {
                   synchronized (locker) {
                       //2.队列中取出一个任务
                       MyTask myTask = queue.take();
                       //3 获取当前时间
                       long curTime = System.currentTimeMillis();
                       //4. 任务执行时间与当前时间进行对比
                       if (myTask.time <=  curTime){
                           //4.1 任务执行时间小于等与当前时间,说明应该要执行任务了
                           myTask.runnable.run();
                       }else {
                           //4.1 任务执行时间大于等与当前时间,说明该任务还没有到执行的时间,再将刚才取出的任务放回原来的队列
                           queue.put(myTask);
                           locker.wait(myTask.time-curTime);

                           //针对这个wait():
                           //1.方便随时唤醒,比如当前时刻是14:00,约定14:30要执行上课任务,
                           //此时取出队首元素,发现时间没有到,就wait(任务执行时间-当前时间)
                           //2.当新的任务来了,需要比之前的队伍提前执行,那么就需要进行唤醒之前的wait(),
                           //重新取队首元素,进行比较时间,确定wait()的时间.

                       }
                   }
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        work.start();
    }

    public void schedule(Runnable runnable, long delay){
        // 根据参数,构造MyTask,插入队列
        MyTask myTask = new MyTask(runnable,delay);
        queue.put(myTask);
        synchronized (locker){
            locker.notify();
        }
    }
}

3.5 思考

我们将锁加在了整个执行任务.此时我们如果只针对wait进行加锁?这样线程安全吗?不安全的话给出理由.

答案:会出现线程不安全的情况

比如下图解释:

我们此时有两个线程,T1线程此时取出一个任务(执行时间为14:30),比较当前时间(14:00),还没有到执行时间,此时将任务推送给队列,但是在推送之前,此时有一个T2线程,正在插入一个新的任务(14:10),同时执行了notify操作,但是此时T1线程并没有wait,此时就空打一炮,此时T1线程开始拿到锁,进行堵塞等待,但是此时等待的时间为(14:30 - 14:00),T2线程插入的新任务还有10分钟需要执行,但是因为之前已经notify一次,此时堵塞的时间无法进行唤醒操作,所以T2线程插入的这个任务要等到14:30才能执行,这就引起线程的不安全.

当我们加锁在整个(取出任务和推送任务),T1线程一定在wait之前不会使得T2线程执行notify操作,因为T1线程在加锁中,等待wait之后才会解除锁,等待T1的锁解除,T2才会执行notify操作. 进而去唤醒T1线程中的wait.