Java多线程基础-10：代码案例之定时器（一）-阿里云开发者社区

定时器就是一个闹钟。它可以设定一个时间，当时间到，就可以执行某个指定的代码。

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

Java标准库（java.util）中提供了一个定时器类：Timer。Timer 类的核心方法为 schedule()。

一、Timer类的使用

下面是使用Timer类创建定时器的代码示例，通过创建Timer对象timer，与调用timer的schedule()方法完成定时器的设定。

1.import java.util.Timer;
import java.util.TimerTask;
 
public class Test {
    public static void main(String[] args) {
        //1-创建Timer对象
        Timer timer = new Timer();
        //2-设定定时效果：5秒
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                System.out.println("hello");
            }
        },5000);
        System.out.println("BBB");
    }
}

运行代码结果如下：立即执行System.out.println("BBB");语句打印出BBB，等待5s后，执行定时器schedule()中设定的语句，打印"hello"。

1、schedule()方法

schedule()方法的作用是在某个特定的时间后，安排执行某个指定的操作。它有多个重载：

这些重载的共同点是，第一个参数为被安排的任务task，第二个参数（或后面的所有参数共同）表示设定的任务将要执行的时间。

以schedule(TimerTask task, long delay)为例，它的两个参数分别是：

task：被安排的任务。
delay：在任务执行之前的等待时间（毫秒数）。

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

这里的第一个参数TimerTask，本质上就是一个Runnable。查看TimerTask的源码可以发现，它其实是一个实现了Runnable接口的抽象类。因此，当创建TimerTask对象时，也需要重写实现run()方法。run()方法中定义的行为，表示任务具体要干什么。

（new TimerTask() { ... }：创建一个匿名内部类，继承自TimerTask，并重写了run()方法。）

程序启动后，立即打印出BBB，但未立即执行计时器timer中的代码。等待5秒后，程序打印hello。

这里有一个小细节：打印完毕hello后，程序并未终止退出。这是因为Timer里内置的前台线程阻止了当前进程结束。事实上，run方法的执行正是靠Timer内部的线程控制在时间到了之后执行的。（后面会讲解如何自己实现一个Timer类，Timer内部的线程是如何控制定时的，在那里会有只管的感受。）

2、定时器的应用场景

定时器的应用场景很多，尤其是在网络编程中。

实际中，很多的“等待”并不是无期限的，而是应当指定一个超时时间。比如打开浏览器，访问CSDN。如果此时的网络状况不是很好，那么加载的时间就可能会非常久。所以，浏览器会设置一个超时时间，如果达到了当前的超时时间还没有等待结果，就会提醒用户不要再等待下去了（504 gateway time out）。

3、用Timer管理多个任务

定时器内部可以管理很多个任务。如以下代码中，同时给定时器注册5个任务：

import java.util.Timer;
import java.util.TimerTask;
 
public class Test {
    public static void main(String[] args) {
        //1-创建定时器对象timer
        Timer timer = new Timer();
 
        //2-多次调用schedule()方法，给定时器注册多个任务
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                System.out.println("hello5");
            }
        },5000);
 
        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");
    }
}

运行程序后，立即打印hello0，之后每隔一秒进行一次打印。

这里就像传说中时间复杂度为O(0)的休眠排序法（笑）（手动滑稽）

二、代码实现Timer

代码实现Timer主要要考虑到两个问题：

a. 如何实现Timer对象可以同时管理多个任务？

虽然任务有很多，但它们的触发事件是不同的。因此，只需要有一个或一组工作线程来负责每次找这些任务中时间最先达到的即可。

换句话说，一个线程先执行最早的的任务，做完了之后再执行第二早的任务，以此类推。而所有任务中，时间到了的就执行，没到的就再等等。

如何实现“每次找到这些任务中时间最先到达的任务”？——堆！

堆heap是这里要用到的核心数据结构！（排序的效率要低于堆，且插入新的元素时，要维持原序列的规律比较困难。）

Java标准库中就提供了 PriorityQueue.

b. 定时器可能是有多个线程在执行 schedule 方法，那么就希望在多线程下操作 PriorityQueue 还能线程安全。

要保证线程安全，就要更进一步：Java标准库中提供了带优先级的阻塞队列，能够解决线程安全这个问题：PriorityBlockingQueue

通过查看优先级阻塞队列的源码可知，它遵循和优先级队列一样的顺序。可以根据任务的执行时间来建小根堆。不断取队头元素，取出的就是其中最小的元素。需要注意的是，该结构只有阻塞的入队列和阻塞的出队列，没有阻塞的查看队头元素方法。

1、实现思路

a.初步代码

首先创建一个MyTimer来模拟Timer，是一个自定义的定时器类。该类中封装有核心数据结构PriorityBlockingQueue。另外，创建一个类MyTask用于描述一个要执行的任务。一个要执行的任务中包含两方面信息，即：具体要做什么+什么时候做。

要特别注意的是，为了后续的判定方便，MyTask中的时间属性设定为绝对时间。

MyTimer定时器类中定义schedule()方法。其中根据传入的参数构造Task，将其插入队列中即可。注意，schedule()参数中的delay指的是相对时间，如3000，表示的是任务要在3000毫秒后执行。

因此，在构造MyTask时，要有一步绝对时间与相对时间之间的转换：

this.time = System.currentTimeMillis() + delay;

System.currentTimeMillis() 用于获取当前毫秒级别的时间戳，即当前时刻和基准时刻的ms数之差（基准时刻是1970年1月1日00：00：00.000）

代码展现如下：

class MyTask{
    public Runnable runnable;
    public long time;   //为了方便后续判定，使用的是绝对的时间戳
 
    public MyTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay; //转换：相对时间delay + 当前时间戳 => 绝对的时间戳
    }
}
 
//自定义定时器类
class MyTimer {
    //核心数据结构，带有优先级的阻塞队列
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();
 
    //此处的delay是一个相对时间，表示间隔多少时间后执行该任务
    public void schedule(Runnable runnable, long delay) {
        //根据参数构造MyTask，插入队列即可
        MyTask myTask = new MyTask(runnable,delay);
        queue.put(myTask);
    }
}

b.构造线程来具体执行任务

在计时器类的构造方法中构造扫描线程，用来扫描优先级阻塞队列中的各个任务是否到达可执行的时间。

逻辑很简单：先从queue中取出一个任务，这个任务应是所有任务中时间最小的。再获取当前时间curTime。通过比较curTime与myTask.time的大小来判断是否达到了该任务的执行时间。如果到达了，则执行myTask.runnable.run()；如果没有达到，那么只能把刚才取出的任务放回队列中。

//注：该代码不是最终版，仅表明思路
 
class MyTimer {
    ...    //其他代码
 
 
    // 在这里构造线程，负责不停地扫描队首元素，判断该任务是否可以执行
    public MyTimer() {
        Thread t = new Thread(()->{
            while (true) {
                try {
                    MyTask myTask = queue.take();
                    long curTime = System.currentTimeMillis();  //获取当前时间
                    if(curTime < myTask.time) {
                        //当前时间小于任务时间：时间还没到
                        //暂不执行，要把刚才取出的任务塞回队列中
                        queue.put(myTask);
                    }else{
                        //时间到了，执行任务
                        myTask.runnable.run();  //执行任务
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

但是上面的代码存在两个严重的问题：

1、当前队列里的MyTask元素是按照什么规则来表示优先级的？

2、while(true)带来了CPU的忙等问题。

Java多线程基础-10：代码案例之定时器（二）+

https://developer.aliyun.com/article/1520554?spm=a2c6h.13148508.setting.17.75194f0e0dvo2R

Java多线程基础-10：代码案例之定时器（一）

一、Timer类的使用

1、schedule()方法

2、定时器的应用场景

3、用Timer管理多个任务

二、代码实现Timer

a. 如何实现Timer对象可以同时管理多个任务？

b. 定时器可能是有多个线程在执行 schedule 方法，那么就希望在多线程下操作 PriorityQueue 还能线程安全。

1、实现思路

热门文章

最新文章

相关课程

相关电子书

相关实验场景