ScheduledThreadPoolExecutor与Timer

首先来看一下Timer类

例子如下：

 package cn.concurrent.executor;

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

 /**
  * Created by spark on 17-9-25.
  */
 public class TestTimer {

     static class Reminder {
         Timer timer;

         public Reminder(int sec) {
             timer = new Timer();
             timer.schedule(new TimerTask() {
                 @Override
                 public void run() {
                     System.out.println("this is Timer.");
                     timer.cancel();
                 }
             }, sec * 1000);
         }
     }

     public static void main(String[] args) {
         System.out.println("------------------");
         new Reminder(5);
         System.out.println("。。。。。。。。。。");
     }
 }

运行结果如下：

------------------
..................
this is timer.

Process finished with exit code 0

运行后，前2行很快就会输出，第三行5秒后出现。

从这个例子可以看出一个典型的利用timer执行计划任务的过程如下：

• new一个TimerTask的子类，重写run方法来指定具体的任务
• new一个Timer类，Timer.schedule(TimerTask),来运行具体的定时任务。
• 调用相关调度方法执行计划。这个例子调用的是schedule方法。
• 任务完成，结束线程。这个例子是调用cancel方法结束线程。

JDK源码来看一下：

     public void schedule(TimerTask var1, long var2) {
         if(var2 < 0L) {
             throw new IllegalArgumentException("Negative delay.");
         } else {
             this.sched(var1, System.currentTimeMillis() + var2, 0L);
         }
     }

     public void schedule(TimerTask var1, Date var2) {
         this.sched(var1, var2.getTime(), 0L);
     }

     public void schedule(TimerTask var1, long var2, long var4) {
         if(var2 < 0L) {
             throw new IllegalArgumentException("Negative delay.");
         } else if(var4 <= 0L) {
             throw new IllegalArgumentException("Non-positive period.");
         } else {
             this.sched(var1, System.currentTimeMillis() + var2, -var4);
         }
     }

     public void schedule(TimerTask var1, Date var2, long var3) {
         if(var3 <= 0L) {
             throw new IllegalArgumentException("Non-positive period.");
         } else {
             this.sched(var1, var2.getTime(), -var3);
         }
     }

     public void scheduleAtFixedRate(TimerTask var1, long var2, long var4) {
         if(var2 < 0L) {
             throw new IllegalArgumentException("Negative delay.");
         } else if(var4 <= 0L) {
             throw new IllegalArgumentException("Non-positive period.");
         } else {
             this.sched(var1, System.currentTimeMillis() + var2, var4);
         }
     }

     public void scheduleAtFixedRate(TimerTask var1, Date var2, long var3) {
         if(var3 <= 0L) {
             throw new IllegalArgumentException("Non-positive period.");
         } else {
             this.sched(var1, var2.getTime(), var3);
         }
     }

     private void sched(TimerTask var1, long var2, long var4) {
         if(var2 < 0L) {
             throw new IllegalArgumentException("Illegal execution time.");
         } else {
             if(Math.abs(var4) > 4611686018427387903L) {
                 var4 >>= 1;
             }

             TaskQueue var6 = this.queue;
             synchronized(this.queue) {
                 if(!this.thread.newTasksMayBeScheduled) {
                     throw new IllegalStateException("Timer already cancelled.");
                 } else {
                     Object var7 = var1.lock;
                     synchronized(var1.lock) {
                         if(var1.state != 0) {
                             throw new IllegalStateException("Task already scheduled or cancelled");
                         }

                         var1.nextExecutionTime = var2;
                         var1.period = var4;
                         var1.state = 1;
                     }

                     this.queue.add(var1);
                     if(this.queue.getMin() == var1) {
                         this.queue.notify();
                     }

                 }
             }
         }
     }

核心方法是 sched(),最终会把任务放入一个TaskQueue的队列中，然后来执行。

默认情况下，创建的timer线程会一直执行，主要有下面四种方式来终止timer线程：

• 调用timer的cancle方法
• 把timer线程设置成daemon线程，（new Timer(true)创建daemon线程），在jvm里，如果所有用户线程结束，那么守护线程也会被终止，不过这种方法一般不用。
• 当所有任务执行结束后，删除对应timer对象的引用，线程也会被终止。
• 调用System.exit方法终止程序

代码如下:

 public void cancel() {
         TaskQueue var1 = this.queue;
         synchronized(this.queue) {
             this.thread.newTasksMayBeScheduled = false;
             this.queue.clear();
             this.queue.notify();
         }
     }

没有显式的线程stop方法，而是调用了queue的clear方法和queue的notify方法，clear是个自定义方法，notify是Objec自带的方法，很明显是去唤醒wait方法的。

 void clear() {
         for(int var1 = 1; var1 <= this.size; ++var1) {
             this.queue[var1] = null;
         }

         this.size = 0;
     }

原理是清空正个队列（底层是一个数列）。

看一下Timer的构造器：

 public Timer(String var1) {
         this.queue = new TaskQueue();
         this.thread = new TimerThread(this.queue);
         this.threadReaper = new Object() {
             protected void finalize() throws Throwable {
                 synchronized(Timer.this.queue) {
                     Timer.this.thread.newTasksMayBeScheduled = false;
                     Timer.this.queue.notify();
                 }
             }
         };
         this.thread.setName(var1);
         this.thread.start();
     }

里面维护一个线程，然后看一下这个线程，如下：

继承Thread类，重写run()方法，看看run()方法的逻辑：

  public void run() {
         boolean var9 = false;

         try {
             var9 = true;
             this.mainLoop();
             var9 = false;
         } finally {
             if(var9) {
                 TaskQueue var4 = this.queue;
                 synchronized(this.queue) {
                     this.newTasksMayBeScheduled = false;
                     this.queue.clear();
                 }
             }
         }

         TaskQueue var1 = this.queue;
         synchronized(this.queue) {
             this.newTasksMayBeScheduled = false;
             this.queue.clear();
         }
     }

看到调用了一个方法mainLoop();其他的操作都是初始化TaskQueue,并清空TaskQueue.

看一下mainLoop()方法。如下:

 private void mainLoop() {
         while(true) {
             while(true) {
                 try {
                     TaskQueue var3 = this.queue;
                     TimerTask var1;
                     boolean var2;
                     synchronized(this.queue) {
                         while(this.queue.isEmpty() && this.newTasksMayBeScheduled) {
                             this.queue.wait();
                         }

                         if(this.queue.isEmpty()) {
                             return;
                         }

                         var1 = this.queue.getMin();
                         Object var8 = var1.lock;
                         long var4;
                         long var6;
                         synchronized(var1.lock) {
                             if(var1.state == 3) {
                                 this.queue.removeMin();
                                 continue;
                             }

                             var4 = System.currentTimeMillis();
                             var6 = var1.nextExecutionTime;
                             if(var2 = var6 <= var4) {
                                 if(var1.period == 0L) {
                                     this.queue.removeMin();
                                     var1.state = 2;
                                 } else {
                                     this.queue.rescheduleMin(var1.period < 0L?var4 - var1.period:var6 + var1.period);
                                 }
                             }
                         }

                         if(!var2) {
                             this.queue.wait(var6 - var4);
                         }
                     }

                     if(var2) {
                         var1.run();
                     }
                 } catch (InterruptedException var13) {
                     ;
                 }
             }
         }
     }

可以看到wait方法，之前的notify就是通知到这个wait，然后clear方法在notify之前做了清空数组的操作，所以会break，线程执行结束，退出。

schedule VS. scheduleAtFixedRate

这两个方法都是任务调度方法，他们之间区别是，schedule会保证任务的间隔是按照定义的period参数严格执行的，如果某一次调度时间比较长，那么后面的时间会顺延，保证调度间隔都是period,而scheduleAtFixedRate是严格按照调度时间来的，如果某次调度时间太长了，那么会通过缩短间隔的方式保证下一次调度在预定时间执行。举个栗子：你每个3秒调度一次，那么正常就是0,3,6,9s这样的时间，如果第二次调度花了2s的时间，如果是schedule，就会变成0,3+2,8,11这样的时间，保证间隔，而scheduleAtFixedRate就会变成0,3+2,6,9，压缩间隔，保证调度时间。