Java并发编程笔记之Timer源码分析

timer在JDK里面，是很早的一个API了。具备延时的，并具备周期性的任务，在newScheduledThreadPool出来以前咱们通常会用Timer和TimerTask来作，可是Timer存在一些缺陷，为何这么说呢？

　　Timer只建立惟一的线程来执行全部Timer任务。若是一个timer任务的执行很耗时，会致使其余TimerTask的时效准确性出问题。例如一个TimerTask每10秒执行一次，而另一个TimerTask每40ms执行一次，重复出现的任务会在后来的任务完成后快速连续的被调用4次，要么彻底“丢失”4次调用。Timer的另一个问题在于，若是TimerTask抛出未检查的异常会终止timer线程。这种状况下，Timer也不会从新回复线程的执行了；它错误的认为整个Timer都被取消了。此时已经被安排但还没有执行的TimerTask永远不会再执行了，新的任务也不能被调度了。

 

这里作了一个小的 demo 来复现问题，代码以下：

package com.hjc;

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

/**
 * Created by cong on 2018/7/12.
 */
public class TimerTest {
    //建立定时器对象
    static Timer timer = new Timer();

    public static void main(String[] args) {
        //添加任务1,延迟500ms执行
        timer.schedule(new TimerTask() {

            @Override
            public void run() {
                System.out.println("---one Task---");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                throw new RuntimeException("error ");
            }
        }, 500);
        //添加任务2，延迟1000ms执行
        timer.schedule(new TimerTask() {

            @Override
            public void run() {
                for (;;) {
                    System.out.println("---two Task---");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }, 1000);

    }
}

如上代码先添加了一个任务在 500ms 后执行，而后添加了第二个任务在 1s 后执行，咱们指望的是当第一个任务输出 ---one Task--- 后等待 1s 后第二个任务会输出 ---two Task---，

可是执行完毕代码后输出结果以下所示：

 

例子2，

 

public class Shedule {
    private static long start;

    public static void main(String[] args) {
        TimerTask task = new TimerTask() {
            public void run() {
                System.out.println(System.currentTimeMillis()-start);
                try{
                    Thread.sleep(3000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        };

        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis()-start);
            }
        };

        Timer timer = new Timer();
        start = System.currentTimeMillis();
        //启动一个调度任务，1S钟后执行
        timer.schedule(task,1000);
        //启动一个调度任务，3S钟后执行
        timer.schedule(task1,3000);


    }

}

上面程序咱们预想是第一个任务执行后，第二个任务3S后执行的，即输出一个1000，一个3000.

实际运行结果以下：

实际运行结果并不如咱们所愿。世界结果，是过了4S后才输出第二个任务，即4001约等于4秒。那部分时间时间到哪里去了呢？那个时间是被咱们第一个任务的sleep所占用了。

如今咱们在第一个任务中去掉Thread.sleep（）；这一行代码，运行是否正确了呢？运行结果以下：

能够看到确实是第一个任务过了1S后执行，第二个任务在第一个任务执行完后过3S执行了。

这就说明了Timer只建立惟一的线程来执行全部Timer任务。若是一个timer任务的执行很耗时，会致使其余TimerTask的时效准确性出问题。

 

Timer 实现原理分析

下面简单介绍下 Timer 的原理，以下图是 Timer 的原理模型介绍：

1.其中 TaskQueue 是一个平衡二叉树堆实现的优先级队列，每一个 Timer 对象内部有惟一一个 TaskQueue 队列。用户线程调用 timer 的 schedule 方法就是把 TimerTask 任务添加到 TaskQueue 队列，在调用 schedule 的方法时候 long delay 参数用来讲明该任务延迟多少时间执行。

2.TimerThread 是具体执行任务的线程，它从 TaskQueue 队列里面获取优先级最小的任务进行执行，须要注意的是只有执行完了当前的任务才会从队列里面获取下一个任务而无论队列里面是否有已经到了设置的 delay 时间，一个 Timer 只有一个 TimerThread 线程，因此可知 Timer 的内部实现是一个多生产者单消费者模型。

 

从实现模型能够知道要探究上面的问题只需看 TimerThread 的实现就能够了，TimerThread 的 run 方法主要逻辑源码以下：

public void run() {
   try {
       mainLoop();
   } finally {
       // 有人杀死了这个线程，表现得好像Timer已取消
       synchronized(queue) {
           newTasksMayBeScheduled = false;
           queue.clear();  // 消除过期的引用
       }
   }
}
 private void mainLoop() {
        while (true) {
            try {
                TimerTask task;
                boolean taskFired;
                //从队列里面获取任务时候要加锁
                synchronized(queue) {
                    ......
                }
                if (taskFired)  
                    task.run();//执行任务
            } catch(InterruptedException e) {
            }
        }
 }

可知当任务执行过程当中抛出了除 InterruptedException 以外的异常后，惟一的消费线程就会由于抛出异常而终止，那么队列里面的其余待执行的任务就会被清除。因此 TimerTask 的 run 方法内最好使用 try-catch 结构 catch 主可能的异常，不要把异常抛出到 run 方法外。

其实要实现相似 Timer 的功能使用 ScheduledThreadPoolExecutor 的 schedule 是比较好的选择。ScheduledThreadPoolExecutor 中的一个任务抛出了异常，其余任务不受影响的。

ScheduledThreadPoolExecutor 例子以下：

/**
 * Created by cong on 2018/7/12.
 */
public class ScheduledThreadPoolExecutorTest {
    static ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);

    public static void main(String[] args) {

        scheduledThreadPoolExecutor.schedule(new Runnable() {

            public void run()  {
                System.out.println("---one Task---");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                throw new RuntimeException("error ");
            }

        }, 500, TimeUnit.MICROSECONDS);

        scheduledThreadPoolExecutor.schedule(new Runnable() {

            public void run() {
                for (int i =0;i<5;++i) {
                    System.out.println("---two Task---");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }

        }, 1000, TimeUnit.MICROSECONDS);

        scheduledThreadPoolExecutor.shutdown();
    }
}

运行结果以下：

之因此 ScheduledThreadPoolExecutor 的其余任务不受抛出异常的任务的影响是由于 ScheduledThreadPoolExecutor 中的 ScheduledFutureTask 任务中 catch 掉了异常，可是在线程池任务的 run 方法内使用 catch 捕获异常并打印日志是最佳实践。