定时器ScheduledExecutorService原理分析

一 简单使用

环境：jdk8

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        ScheduledExecutorService executorService=new ScheduledThreadPoolExecutor(1);
        executorService.scheduleWithFixedDelay(()->{
            System.out.println(dtf.format(LocalDateTime.now()));
        },1,3, TimeUnit.SECONDS);

有关spring中定时器使用，请点击https://blog.csdn.net/yegeg/article/details/121654509

从new ScheduledThreadPoolExecutor可以看出，我们这个定时器也和线程池有关系，接下来看ScheduledThreadPoolExecutor类

 它扩展了ThreadPoolExecutor ，说明它也是一个线程池，也实现了ScheduledExecutorService ，这个接口定义了定时器所拥有的方法

public interface ScheduledExecutorService extends ExecutorService {

    /**
     * Creates and executes a one-shot action that becomes enabled
     * after the given delay.
     *
     */
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);

    /**
     * Creates and executes a ScheduledFuture that becomes enabled after the
     * given delay.
     */
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);

    /**
     * Creates and executes a periodic action that becomes enabled first
     * after the given initial delay, and subsequently with the given
     * period; that is executions will commence after
     * {@code initialDelay} then {@code initialDelay+period}, then
     * {@code initialDelay + 2 * period}, and so on.
     * If any execution of the task
     * encounters an exception, subsequent executions are suppressed.
     * Otherwise, the task will only terminate via cancellation or
     * termination of the executor.  If any execution of this task
     * takes longer than its period, then subsequent executions
     * may start late, but will not concurrently execute.
     */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

    /**
     * Creates and executes a periodic action that becomes enabled first
     * after the given initial delay, and subsequently with the
     * given delay between the termination of one execution and the
     * commencement of the next.  If any execution of the task
     * encounters an exception, subsequent executions are suppressed.
     * Otherwise, the task will only terminate via cancellation or
     * termination of the executor.
     */
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

}

我们常用的shedule、fixedRate、fixedDelay都在这里有提前申明

二 ScheduledExecutorService和线程池有什么关系

从ScheduledThreadPoolExecutor类继承，我们就知道 ScheduledExecutorService继承于ThreadPoolExecutor ，那么我们定时任务也是用线程池中规则来执行的，这篇文章，我们重点关注是ScheduledExecutorService，现在我们来看下ScheduledThreadPoolExecutor的scheduleWithFixedDelay源码

 public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (delay <= 0)
            throw new IllegalArgumentException();
         // ①
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          unit.toNanos(-delay));
         
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);// ②
        sft.outerTask = t;
        delayedExecute(t);  // ③
        return t;
    }

这个函数主要做了三件事 

① 把我们的执行任务、延时、执行周期包装成ScheduledFutureTask

sequenceNumber 任务在创建时候递增，如果两个任务执行时间相同，就可以根据该变量来判断哪个任务先执行

time 任务执行需要等待时间

period 执行周期，如果是正数表示fixedRate任务，如果是负数表示fixedDelay任务，0表示非重复任务

② 执行了decorateTask方法，主要作用是一个扩展点，允许用户修改和替换task

③ 通过delayedExecute把任务放到一个队列中，并且通过ensurePrestart方法去保证至少有一个线程开始执行，ensurePrestart是线程池的方法，它保证有线程能启动去执行任务，有关线程池的原理，将在线程池文章中分析

private void delayedExecute(RunnableScheduledFuture<?> task) {
        if (isShutdown())
            reject(task);
        else {
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

到这里，把任务封装成一个task 放到队列中，并且开启了线程来执行。

三 它是怎么实现周期性调用呢

通过上面，我们把任务放到队列，并且开启线程来执行，他是怎么执行呢，我们知道用Thread去启动一个任务的时候，这个任务可以实现Runnable接口，然后去执行他里面的run，我们上面说封装的ScheduledFutureTask任务，也是实现了Runnable接口，那么线程在执行的时候，也会去执行run，我们来看下ScheduledFutureTask中重写run方法

 public void run() {
            boolean periodic = isPeriodic();//①
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            else if (!periodic)
                ScheduledFutureTask.super.run();// ②
            else if (ScheduledFutureTask.super.runAndReset()) { // ③
                setNextRunTime();
                reExecutePeriodic(outerTask); 
            }
        }

①处就是判断是不是周期任务，如果ScheduledFutureTask的变量period不等于0 表示周期任务

② 如果是一次性任务就执行ScheduledFutureTask.super.run()，执行这个方法的时候会去执行FutrueTask中的run。里面调用了我们自己写的要执行的任务，把这里理解成去执行我们自己的任务。

③ 如果是周期任务 就执行ScheduledFutureTask.super.runAndReset()并且获取下次执行的时间，我们先来看下runAndReset是什么，它也是FutrueTask中的方法，执行了该方法后，它会重置为初始状态。

setNextRunTime()去设置我们任务下次执行的所需等待的时间，这里就体现了fixedRate和fixedDelay执行周期的差别。

reExecutePeriodic又把我们的任务重新放到队列中，启动一个线程去执行

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        if (canRunInCurrentRunState(true)) {
            super.getQueue().add(task);
            if (!canRunInCurrentRunState(true) && remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

这样就实现了我们任务周期性调用，放入队列-->调用任务-->计算下次执行时间-->放入队里-->调用任务-->计算下次执行时间....

四 怎么实现获取即将要执行的任务

从上面分析，我们知道了任务是怎么周期性的执行，我们也知道每个任务都有等待时间，那么我们是怎么获取即将要执行的等待时间最短的任务呢，等待这段时间线程做了什么？这里用到一个叫DelayedWorkQueue的队列，他是一个阻塞队列，线程池中的线程会通过他的taken来获取要执行的任务，taken方法会阻塞直到能获取最近要执行的任务才返回，任务是放到一个最小堆里面，堆顶就是等待时间最少的任务，如果任务等待时间还没有到达，线程就会被阻塞，释放cup

思考下

DelayedWorkQueue队列在新增和移除任务时候，是怎样实现最小堆存放的

调用taken时候，是怎么把线程阻塞起来，又怎么被唤醒