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，压缩间隔，保证调度时间。