简单的任务调度

java 定时器Timer

在业务中， 我们往往有这样的需求：某个任务每隔一段时间中执行某个任务， 或者在每天n点中执行某个任务。 自然而然我们想到了使用定时器。
下面我就是用Timer写一下：

timer = new Timer(true);
timer.schedule(
new TimerTask() {
     public void run(){
         doSomething(..);   // 此处为业务逻辑
     }
}, delay, interval);

这样我们就完成一个一个任务在delay秒后每格interval秒执行依次。
当然timer还有几个重载的方法， 这里就不做介绍了。

<span style="color:red;">我们要注意， 这里的时间由于JVM线程调度和线程等待等因素， 不能保证任务在指定时间内执行。</span>

ScheduledExecutorService

自从java5开始， 加入了并发库java.util.concurrent，使得多线程操作变得相对容易了, 想学习该包的可以看Jakob Jenkov的博客中。 在本次主题中， 我只将一下再java.util.concurrent的ScheduledExecutorService这个类，首先我们还是来看一下用法：

// 通过Executors来构造创建ScheduledExecutorService对象
    ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
    ScheduledFuture<?> future = service.schedule(new Runnable() {
        @Override
        public void run() {
            doSomething();
        }
    },10, TimeUnit.SECONDS);

以上是10秒钟之后执行runnable中的任务。

为什么java5要推出一个这样的线程调度呢？
首先来分析一下Timer的源码：

public class Timer{
    private final TaskQueue queue = new TaskQueue();
    private final TimerThread thread = new TimerThread(queue);
}
1个timer实例中有两个重要的成员： taskqueue 任务队列存放多个task， thread 线程， 用来执行task的线程。

再来TimerThread线程所做的事情：
   try {
            mainLoop();  // 一个循环
        } finally {// 退出循环， 清空任务队列， 
         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)
                        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();
            }
        }
    }

我们可以看到， mainloop主要做的事情就是
循环获取queue中的任务， 计算任务执行的时间， 如果该任务只进行一次或者已经取消了， 那么该任务会被移除。  
如果当前时间超过了该任务的执行时间， 首先设定该任务下次执行时间，并且调整该任务在queue中的位置( queue.rescheduleMin()) 
然后执行任。


注意task.run()为执行任务， 在当前线程中。

进行了源码分析后，我们可以看到以下缺点：

1. 任务调度延迟同步
   我们发现Timer 只有1个线程去调度多个任务， 而每个任务的执行是在timer内部的这个线程中， 假如一个任务执行正在执行或者执行时间过久， 那么这个timer管理的其他任务执行即使时间到了， 也不会立刻被执行。
2. 绝对时间（该问题大部分可以忽略）
   currentTime = System.currentTimeMillis();
   此时间依赖于系统时间， 一旦系统时间变化， 任务调度将会发生问题。
3. 非InterruptedException e 异常未处理（严重）
   我们发现，在该线程中捕获的仅仅是任务被打断这个异常，那么在执行的任何一个任务内部抛出其他异常， 整个线程将终止， timer视为终止， 所有任务都会被移除。

对于简单的任务，如果Timer可以满足需求，那么用一下也无妨，但还是建议使用ScheduleExecutorService. timer在一些测试环境下可以编写。

以上两个是jdk提供的任务调度的工具包， 能够实现诸如简单的任务调用，但还有一些更复杂的任务调度求并不能满足， 比如不支持cron表达式、 由于服务器终止等原因任务无法恢复。 所以一些任务调度框架诞生了， 在后续我会介绍Quartz Java调度框架。