【源码剖析】定时器 详解

首先，本人来展示下 JDK所提供的定时器 的基本使用：

使用展示：

---

那么，本人现在来讲解下 JDK所提供的定时器的 底层核心源码：

源码详解：

使用总结：

根据上文讲解，我们能够知道，使用JDK所提供的 Timer 和 TimerTask 类，基本步骤如下：

• 根据具体需求，定义一个 TimerTask类 的 实现子类
• 构造 Timer对象
  （一般来讲，空参构造即可）
• 构造 自定义TimerTask实现类 的 对象
  （一般来讲，空参构造即可，上文展示只是为了在执行逻辑后，直接调用cancel方法）
• Timer对象 调用 schedule()方法，参数如下：

• TimerTask task, Date firstTime, long period
• TimerTask task, long delay, long period
• TimerTask task, Date time
• TimerTask task, long delay

那么，本人将以基本步骤为顺序，来讲解 JDK所提供的 定时器 的 源码

---

首先是 TimerTask类 的 空参构造：

TimerTask类 🥕 空参构造：

可以看到：

空参构造，什么都没有做
因此，空参构造的意义是：

创建TimerTask对象，以及 为静态变量赋值

那么，我们来看看，TimerTask类 都有哪些成员属性：

TimerTask类 🥕 成员属性：

/**
 * This object is used to control access to the TimerTask internals.
 */
final Object lock = new Object();

/**
 * The state of this task, chosen from the constants below.
 */
int state = VIRGIN;

/**
 * This task has not yet been scheduled.
 */
static final int VIRGIN = 0;

/**
 * This task is scheduled for execution.  If it is a non-repeating task,
 * it has not yet been executed.
 */
static final int SCHEDULED   = 1;

/**
 * This non-repeating task has already executed (or is currently
 * executing) and has not been cancelled.
 */
static final int EXECUTED    = 2;

/**
 * This task has been cancelled (with a call to TimerTask.cancel).
 */
static final int CANCELLED   = 3;

/**
 * Next execution time for this task in the format returned by
 * System.currentTimeMillis, assuming this task is scheduled for execution.
 * For repeating tasks, this field is updated prior to each task execution.
 */
long nextExecutionTime;

/**
 * Period in milliseconds for repeating tasks.  A positive value indicates
 * fixed-rate execution.  A negative value indicates fixed-delay execution.
 * A value of 0 indicates a non-repeating task.
 */
long period = 0;

可以看到，其实就只有以下几种 对象成员属性：

• 锁对象
• 当前task状态，及其枚举值：

• 未使用
• 已定时，还未执行（若是repeating模式，则是处于定时状态）
• 已执行（一定是non-repeating模式）
• 已取消

• 下次执行时间
• 执行时间间隔（一定是repeating模式）

---

在上文的空参构造源码中，本人故意多展示了一段代码 —— run方法
这就代表着，TimerTask类 是一个 Runnable子类：

TimerTask类 🥕 继承关系：

可以看到：

TimerTask类 是一个 Runnable子类，因此使用时一般会 创建新线程 去调用 run方法逻辑
TimerTask类 是一个 抽象类，run方法逻辑 由调用方自己实现

---

接下来，本人来讲解下 Timer类：

首先，本人来展示下 Timer类的 成员属性：

Timer类 🎃 成员属性：

可以看到，成员属性有两个：

• queue：定时任务队列
• thread：定时器线程

---

Timer类 🎃 空参构造：

可以看到，仅仅是包装了一层其它参数的构造方法，我们点进去：

可以看到，仅仅是创建了thread成员，并启动该线程。
那么，启动该线程，就会执行该线程的 run方法

---

我们来看看 TimerThread类 的 run方法，执行了什么逻辑：

TimerThread类 🥑 run方法：

可以看到，run方法的逻辑如下：

• 调用执行 mainLoop方法
• 在 线程结束前，同步式 关闭定时器，清除queue

---

那么，主要逻辑就锁定在了 mainLoop方法：

TimerThread类 🥑 mainLoop方法：

/**
 * 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) {
        }
    }
}

代码很长，具体逻辑如下：

• while(true) 式 执行逻辑
• synchronized(queue) 式 保证线程安全，取出 可执行(定时时间到) 的 task：

• 等待 task入队，没有task前 则一直 wait，不占用CPU资源
• 获取 最近要执行 的 task
• synchronized(task.lock) 式

• 判断 当前task 是否 cancel，若 cancel，则从queue 中移除，继续获取 下一个task 进行判断
• 判断 当前task 是否 定时时间到，将是否时间到记录在 taskFired变量 中
• 若时间到了，则根据 是否为 repeating模式，选择是否 新创建一个task入队
• 若时间未到，则计算 定时时间，超时wait 当前queue

• 若 taskFired变量 为 true，则 执行当前task

---

那么，以上就是JDK所提供的定时器的 核心逻辑。
相信看到这里，同学们就大致能明白 JDK所提供的 定时器内部的执行逻辑了！
想一年前，开始看源码，是真的很不适应，因此希望能帮到在了解源码的同学！

（本人也在之前自己实现了 定时器 —— 《详解 定时器 的基本实现》）