前言:
大家好,我是良辰丫,今天我们一起了解一下定时器,通过定时器来熟悉一下线程安全等相关知识点.💞💞💞

🧑个人主页：良辰针不戳
📖所属专栏：javaEE初阶
🍎励志语句：生活也许会让我们遍体鳞伤，但最终这些伤口会成为我们一辈子的财富。
💦期待大家三连，关注，点赞，收藏。
💌作者能力有限，可能也会出错，欢迎大家指正。
💞愿与君为伴，共探Java汪洋大海。

定时器

• 1. 简述定时器
• 2. java标准库中的定时器
• 3. 自己实现定时器

1. 简述定时器

定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码.安排一个任务,不是立即完成,而是在指定时间到达后执行.

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

2. java标准库中的定时器

import java.util.Timer;
import java.util.TimerTask;

public class Test18 {
    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("hello0");
    }
}

标准库的定时器,其实本质就是Runnable,这个方法的执行是靠Timer内部的线程在时间到了之后执行的.咱们来简单瞧一下源码,有一个延迟时间delay,如果延迟时间小于0,就会抛出异常;反之就会形成定时器,把任务加载到队列中,时间未到,就会阻塞等待,时间到了唤醒任务.

3. 自己实现定时器

定时器,内部管理的步数一个任务,可以管理很多任务,我们需要用到一种数据结构,定时器肯定与时间有关,这时,我们想到了堆,优先级队列不就默认是一种小根堆嘛?定时器中,可能多个任务在执行,优先级队列还能保证线程安全.

• 一个带优先级的阻塞队列.因为阻塞队列中的任务都有各自的执行时刻 (delay). 最先执行的任务一定是 delay 最小的. 使用带优先级的队列就可以高效的把这个 delay 最小的任务找出来.
• 队列中的每个元素是一个 Task 对象.
• Task 中带有一个时间属性, 队首元素就是即将要执行的元素.
• 有一个 worker 线程一直扫描队首元素, 看队首元素是否需要执行.

import java.util.concurrent.PriorityBlockingQueue;
class MyTask2 implements Comparable<MyTask2> {
    public Runnable runnable;
    public long time;
    public MyTask2(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

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

class MyTimer2 {
    private PriorityBlockingQueue<MyTask2> queue = new PriorityBlockingQueue<>();

    // 创建一个锁对象
    private Object locker = new Object();

    // 此处的 delay 是一个形如 3000 这样的数字 (多长时间之后, 执行该任务)
    public void schedule(Runnable runnable, long delay) {
        // 根据参数, 构造 MyTask, 插入队列即可.
        MyTask2 myTask = new MyTask2(runnable, delay);
        queue.put(myTask);
        synchronized (locker) {
            locker.notify();
        }
    }
    // 在这里构造线程, 负责执行具体任务了.
    public MyTimer2() {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    synchronized (locker) {
                        // 阻塞队列, 只有阻塞的入队列和阻塞的出队列, 没有阻塞的查看队首元素.
                        MyTask2 myTask = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (myTask.time <= curTime) {
                            // 时间到了, 可以执行任务了
                            myTask.runnable.run();
                        } else {
                            // 时间还没到
                            // 把刚才取出的任务, 重新塞回队列中.
                            queue.put(myTask);
                            locker.wait(myTask.time - curTime);
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}
public class Test17 {
    public static void main(String[] args) {
        // System.out.println(System.currentTimeMillis());
        MyTimer2 myTimer = new MyTimer2();
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello4");
            }
        }, 4000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello3");
            }
        }, 3000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello2");
            }
        }, 2000);
        myTimer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello1");
            }
        }, 1000);

        System.out.println("hello0");
    }
}

使用wait来等待处理,而不是使用sleep,wait方便随时提前唤醒.比如目前是早上八点,打算八点半外出,但是八点十分别人又给自己安排了任务,此时线程就被唤醒,要执行某个任务(避免忙等的情况).