关于java:ThreadPoolTaskScheduler-周期任务原理

ThreadPoolTaskScheduler 外围就是schedule 办法

public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler = this.errorHandler;
        if (errorHandler == null) {
            errorHandler = TaskUtils.getDefaultErrorHandler(true);
        }
      // 最终调用ReschedulingRunnable.schedule 办法
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

后续进入ReschedulingRunnable.schedule 办法，该类中executor 属性为ScheduledThreadPoolExecutor 类，属性为ScheduledThreadPoolExecutor 类继承了ThreadPoolExecutor 线程池，然而自定义了DelayedWorkQueue 提早队列，而不是应用ThreadPoolExecutor 类自带的队列，周期工作提早执行的根本原因就是DelayedWorkQueue 这个提早队列。

public ScheduledFuture<?> schedule() {
    synchronized (this.triggerContextMonitor) {
        this.scheduledExecutionTime = this.trigger.nextExecutionTime(this.triggerContext);
        if (this.scheduledExecutionTime == null) {
            return null;
        }
        long initialDelay = this.scheduledExecutionTime.getTime() - System.currentTimeMillis();
        this.currentFuture = this.executor.schedule(this, initialDelay, TimeUnit.MILLISECONDS);
        return this;
    }
}

DelayedWorkQueue 类通过一个最小堆来存储ThreadPoolTaskScheduler 中的工作，各工作会进行比拟，最快要执行的工作放在最小堆顶部。放入最小堆，通过siftUp，取出最小堆，通过siftDown。

/**
 * 上浮
 */
private void siftUp(int k, RunnableScheduledFuture<?> key) {
    // 始终遍历到根节点下方
    while (k > 0) {
        // 二叉堆，最高节点坐标为0
        // 父节点，(k - 1)/2
        int parent = (k - 1) >>> 1;
        RunnableScheduledFuture<?> e = queue[parent];
        // 指标比父节点大
        // 不须要再上浮，间接跳出
        if (key.compareTo(e) >= 0)
            break;
        // 指标节点比父节点小
        // 持续上浮，以后坐标填入父节点
        queue[k] = e;
        setIndex(e, k);
        // 以后坐标设为父节点坐标
        k = parent;
    }
    // 指标上浮到最小节点坐标，填入该坐标
    queue[k] = key;
    setIndex(key, k);
}

/**
 * 下沉
 */
private void siftDown(int k, RunnableScheduledFuture<?> key) {
    // half = size/2;
    // 二叉堆，最高节点坐标为0
    // 任何节点，其左子节点坐标(k*2)+1，右子节点坐标(k*2)+2
    int half = size >>> 1;
    // 须要拿到子节点，所以只须要到size/2 即可，不须要到最底层
    while (k < half) {
        // 左节点坐标
        int child = (k << 1) + 1;
        RunnableScheduledFuture<?> c = queue[child];
        // 右节点坐标
        int right = child + 1;
        // 左节点比右节点大
        if (right < size && c.compareTo(queue[right]) > 0)
            // 最小 = 右子节点
            c = queue[child = right];
        // 指标最小比子节点小
        // 不再须要下沉，间接退出，指标填入以后坐标
        if (key.compareTo(c) <= 0)
            break;
        // 指标比子节点大
        // 持续下沉，小子节点放到以后节点坐标
        queue[k] = c;
        setIndex(c, k);
        // 以后坐标设为子节点坐标
        // 坐标一直下沉
        k = child;
    }
    // 以后坐标为指标对象最小状况下的坐标
    // 讲指标对象放入该坐标
    queue[k] = key;
    setIndex(key, k);
}

当从DelayedWorkQueue 队列中取出工作时，会取出最小堆顶部的工作，也就是最快要执行的工作，而后线程期待指定工夫。等待时间完结后，通过自旋实现工作。

public RunnableScheduledFuture<?> take() throws InterruptedException {
    ...
    for (;;) {
        RunnableScheduledFuture<?> first = queue[0];
        ...
        if (delay <= 0)
            return finishPoll(first);
        ...
        available.awaitNanos(delay);
        ...
    }
   ...
}