介绍

这个是个JDK远古时代的api了，据考证，可以追溯到JDK 1.3 的时候，历史就不讲了，毕竟我们不是技术考古。还是按照我们以前的方式，废话少说直接上车吧。

简单使用

我们先直接new一个Timer对象：

java.util.Timer timer = new Timer();复制代码

然后调用时，发现可用的方法并不多：

根据多年算命经验，我猜既然是定时任务，那么包含关键字schedule的就是核心方法了，挑个最简单的写下来：

import java.util.Date;import java.util.Timer;import java.util.TimerTask;/** * @author mars酱 */public class MarsTimer {    public static void main(String[] args) {        java.util.Timer timer = new Timer();        timer.schedule(new TimerTask() {            @Override            public void run() {                System.out.println("当前时间:" + new Date());            }        }, 1000, 5000);    }}复制代码

运行了一下，得到了个结果：

结果是每五秒执行一次输出。

Timer的schedule函数有三个参数：

TimerTask：这个就是需要安排的任务对象了，可以new一个之后像我一样实现它的run方法；

delay：在任务执行之前延迟多久，单位是毫秒；

period：每次执行之间的间隔多久，单位也是毫秒；

好了，就是这么简单，感觉再复杂也复杂不到哪里去了

会不会有阻塞？

我们理想的定时任务，应该是多个定时器同步并发执行，各自之间不受影响，对吧？那我们试试Timer会不会有这样的情况吧。

我们假设两个任务，一个任务在执行的过程中导致某些不可抗拒的原因，延迟了5秒，那么另一个任务的执行是不是会被这个延迟的任务影响，理想的情况下的两个定时任务各自完成自己任务，互不干涉和影响。

import java.util.Date;import java.util.Timer;import java.util.TimerTask;/** * @author mars酱 */public class MarsTimer {    public static void main(String[] args) {//        java.util.Timer timer = new Timer();//        timer.schedule(new TimerTask() {//            @Override//            public void run() {//                System.out.println("当前时间:" + new Date());//            }//        }, 1000, 5000);        // 1. 创建第一个任务，打印时间后延迟5秒        TimerTask tta = new TimerTask() {            @SneakyThrows            @Override            public void run() {                System.out.println(">> 这是a任务：当前时间：" + new Date());                Thread.sleep(5000);            }        };        // 2. 创建第二个任务，直接打印毫秒数        TimerTask ttb = new TimerTask() {            @Override            public void run() {                System.out.println("<< 这是b任务：当前毫秒：" + System.currentTimeMillis());            }        };        Timer timera = new Timer();        // 3. 把两个任务都加入计时器中        timera.schedule(tta, 1000, 5000);        timera.schedule(ttb, 1000, 5000);    }}复制代码

运行一下，得到结果：

看出什么来了吗？是不是从结果中没看明白？我就知道，那么我们去掉那段Thread.sleep，得到的结果类似这样：

对比一下上下两个结果，这下是不是明白了？由于a任务的延迟，导致了b任务受到了影响。看来JDK的定时任务是存在阻塞情况的，b任务执行只能等待a完成之后才能执行。

怎么解决？

先不解决，那是下一章节的内容，哈哈哈哈

其他方法

我们先介绍完Timer和TimerTask吧。

TimerTask是个抽象类，依赖Runnable接口，实现TimerTask，我们只要实现run函数就行了，就像这样：

import java.util.TimerTask;/** * @author mars酱 */public class DefaultTimerTask extends TimerTask {    @Override    public void run() {        // 你的业务实现    }}复制代码

翻看java.util.Timer的源代码，核心点如下：

    /**     * Schedule the specified timer task for execution at the specified     * time with the specified period, in milliseconds.  If period is     * positive, the task is scheduled for repeated execution; if period is     * zero, the task is scheduled for one-time execution. Time is specified     * in Date.getTime() format.  This method checks timer state, task state,     * and initial execution time, but not period.     *     * @throws IllegalArgumentException if <tt>time</tt> is negative.     * @throws IllegalStateException if task was already scheduled or     *         cancelled, timer was cancelled, or timer thread terminated.     * @throws NullPointerException if {@code task} is null     */    private void sched(TimerTask task, long time, long period) {        if (time < 0)            throw new IllegalArgumentException("Illegal execution time.");        // Constrain value of period sufficiently to prevent numeric        // overflow while still being effectively infinitely large.        if (Math.abs(period) > (Long.MAX_VALUE >> 1))            period >>= 1;        synchronized(queue) {            if (!thread.newTasksMayBeScheduled)                throw new IllegalStateException("Timer already cancelled.");            synchronized(task.lock) {                if (task.state != TimerTask.VIRGIN)                    throw new IllegalStateException(                        "Task already scheduled or cancelled");                task.nextExecutionTime = time;                task.period = period;                task.state = TimerTask.SCHEDULED;            }            queue.add(task);            if (queue.getMin() == task)                queue.notify();        }    }复制代码

这段大致的意思就是往Timer内部的一个队列里面塞任务，塞的时候做了很多检查，比如周期、任务状态等等，用到了关键字synchronized，那么说明这个队列是个资源共享的，每次操作的时候必须锁一下，那么我们再看下Timer在执行队列的部分源代码：

    /**     * The main timer loop.  (See class comment.)     */    private void mainLoop() {        while (true) {            try {                TimerTask task;                boolean taskFired;                synchronized(queue) {                    // Wait for queue to become non-empty                    while (queue.isEmpty() && newTasksMayBeScheduled)                        queue.wait();                    if (queue.isEmpty())                        break; // Queue is empty and will forever remain; die                    // Queue nonempty; look at first evt and do the right thing                    long currentTime, executionTime;                    task = queue.getMin();                    synchronized(task.lock) {                        if (task.state == TimerTask.CANCELLED) {                            queue.removeMin();                            continue;  // No action required, poll queue again                        }                        currentTime = System.currentTimeMillis();                        executionTime = task.nextExecutionTime;                        if (taskFired = (executionTime<=currentTime)) {                            if (task.period == 0) { // Non-repeating, remove                                queue.removeMin();                                task.state = TimerTask.EXECUTED;                            } else { // Repeating task, reschedule                                queue.rescheduleMin(                                  task.period<0 ? currentTime   - task.period                                                : executionTime + task.period);                            }                        }                    }                    if (!taskFired) // Task hasn't yet fired; wait                        queue.wait(executionTime - currentTime);                }                if (taskFired)  // Task fired; run it, holding no locks                    task.run();            } catch(InterruptedException e) {            }        }    }复制代码

Timer在构造函数中就调用了start函数，start函数底层可以理解为用jvm去调用run函数，而这个mainLoop函数是Timer函数的实现部分，所以，最终Timer的执行都是在这里了。大致的执行顺序解释：

检查队列的情况，是不是空，是不是状态正常；当前任务的状态是不是可以执行；当前任务是不是已经到了可以触发的时间了以上情况都ok，那就执行我们之前实现TimerTask的run函数

以上四点过程，全程都用synchronized包裹。

总结

Timer和TimerTask是JDK原生提供的定时任务实现方案，简单易用，但是平时的场景也经常会有业务处理过程较长的情况，但是单个任务的执行不能影响其他任务的定时情况，所以如果处理定时任务的并发，我们可以使用线程池，下个站见。