阿光附体，浅谈Timer，源码分析。

傷城~ 2023-10-07 21:03 11阅读 0赞

奥里给，奥里给，每天充满正能量！

说到Java的定时器，是不是想起了伟大的Timer，提起Timer是不是想起Netflix的Spring Cloud的注册中心Eureka，如果没记错，它内部定时发送心跳的的机制就是用Timer做的，不过后来的一些注册中心（比如Nacos）都用ScheduledExecutorService代替了，今天我们来浅谈一下这个Timer。

我们先看看它怎么用

import java.util.Timer;
    import java.util.TimerTask;
    
        public class TimerTest {
        
            public static void main(String[] args) {
        
                // 创建Timer对象
                Timer timer = new Timer();
                // 调用scheduleAtFixedRate方法执行定时任务，延迟5s后，每间隔1s就发送一次“hello，光sir !”
                timer.scheduleAtFixedRate(new TimerTask() {
        
                    @Override
                    public void run() {
        
                        System.out.println("hello，光sir !");
                    }
                },5000,1000);
            }
        }

那么它又是怎么实现定时任务的呢？

我们来简单分析一下，从new Timer()开始

public Timer() {
        
        // 调用有参构造函数，并传入线程的名字，这里使用原子计数器AtomicInteger实现i++的操作
        this("Timer-" + serialNumber());
    }
    
    public Timer(String name) {
        
        thread.setName(name);
        // 开始调用Tread类的本地方法start0()启动新线程并让这个线程执行run()方法
        thread.start();
    }

而此处的thread是 `private final TimerThread thread = new TimerThread(queue);`

class TimerThread extends Thread

进而start之后会执行TimerThread的run方法

public void run() {
        
            try {
        
                mainLoop();
            } finally {
        
                // Someone killed this Thread, behave as if Timer cancelled
                synchronized(queue) {
        
                    newTasksMayBeScheduled = false;
                    queue.clear();  // Eliminate obsolete references
                }
            }
        }

// 核心代码
     private void mainLoop() {
        
             while (true) {
        
                 try {
        
                     TimerTask task;
                     boolean taskFired;
                     // 计算时间
                     synchronized(queue) {
        
                         // Wait for queue to become non-empty
                         while (queue.isEmpty() && newTasksMayBeScheduled)
                             // 任务开始执行时队列为空，则等待锁释放，newTasksMayBeScheduled是一个证明当前任务有效的标识，没有标志位的情况为不在需要执行timer了，比如cancel或被gc的时候
                             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
                         task = queue.getMin();
                         synchronized(task.lock) {
        
                             // 如果该task已经被置为cancelled，则将它从队列里面移出
                             if (task.state == TimerTask.CANCELLED) {
        
                                 queue.removeMin();
                                 continue;  // No action required, poll queue again
                             }
                             currentTime = System.currentTimeMillis();
                             executionTime = task.nextExecutionTime;
                             if (taskFired = (executionTime<=currentTime)) {
        
                                 // period表示该task是一次性的，用完就移出
                                 if (task.period == 0) {
         // Non-repeating, remove
                                     // 移出task，这块会有queue的重新排序
                                     queue.removeMin();
                                     // 更新状态为执行中
                                     task.state = TimerTask.EXECUTED;
                                 } else {
         // Repeating task, reschedule
                                     // 可重复执行的task操作，将重新计算下次执行时间，并重新排序    
                                     // 重点，此处解释为什么period分正负：区别schedule方法和scheduleAtFixedRate
                                     // 如果是负数，则以当前时间为准，往后计算下次执行时间
                                     // 如果是正数，则以理论时间为准，往后计算下次执行时间
                                     queue.rescheduleMin(
                                       task.period<0 ? currentTime   - task.period
                                                     : executionTime + task.period);
                                 }
                             }
                         }
                         // 如果还没到任务执行时间就处于等待
                         if (!taskFired) // Task hasn't yet fired; wait
                             queue.wait(executionTime - currentTime);
                     }
                     // 执行task中的run方法，而不是start方法，所以并不是另起一个线程进行操作,递归执行任务，实现定时操作
                     if (taskFired)  // Task fired; run it, holding no locks
                         task.run();
                 } catch(InterruptedException e) {
         //如果是不能捕获的异常，就会有风险了
                 }
             }
         }