ScheduledThreadPoolExecutor 源码分析

ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor 是能够在给定的延时之后、或周期性执行被提交任务的线程池

创建实例

    /**
     *  线程池关闭时是否需要继续执行周期性任务
     */
    private volatile boolean continueExistingPeriodicTasksAfterShutdown;

    /**
     *  线程池关闭时是否需要执行已经存在的延时任务
     */
    private volatile boolean executeExistingDelayedTasksAfterShutdown = true;

    /**
     *  执行 ScheduledFutureTask.cancel 操作时是否需要将任务从任务队列中移除
     */
    volatile boolean removeOnCancel;

    /**
     * Sequence number to break scheduling ties, and in turn to
     * guarantee FIFO order among tied entries.
     */
    private static final AtomicLong sequencer = new AtomicLong();

    /**
     *  默认的线程超时时间为 10 毫秒
     */
    private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
                DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                new DelayedWorkQueue());
    }

    public ScheduledThreadPoolExecutor(int corePoolSize,
            ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE,
                DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                new DelayedWorkQueue(), threadFactory);
    }

    public ScheduledThreadPoolExecutor(int corePoolSize,
            RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE,
                DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                new DelayedWorkQueue(), handler);
    }

    public ScheduledThreadPoolExecutor(int corePoolSize,
            ThreadFactory threadFactory,
            RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE,
                DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                new DelayedWorkQueue(), threadFactory, handler);
    }

    private class ScheduledFutureTask<V>
        extends FutureTask<V> implements RunnableScheduledFuture<V> {

        /** Sequence number to break ties FIFO */
        private final long sequenceNumber;

        /** 当前任务需要在指定的纳秒时间后执行 */
        private volatile long time;

        /**
         *  重复任务的执行周期，以纳秒为单位
         *  正数表示以 fixed-rate 模式执行
         *  负数表示以 fixed-delay 模式执行
         *  0 表示不需要重复执行
         */
        private final long period;

        /** 需要重新入队的周期性任务  */
        RunnableScheduledFuture<V> outerTask = this;

        /**
         *  当前任务在延迟队列中的索引，以支持快速删除
         */
        int heapIndex;

        /**
         *  创建一个在 triggerTime 执行的一次性任务
         */
        ScheduledFutureTask(Runnable r, V result, long triggerTime,
                long sequenceNumber) {
            super(r, result);
            this.time = triggerTime;
            this.period = 0;
            this.sequenceNumber = sequenceNumber;
        }

        /**
         *  创建一个在 triggerTime 第一次执行，并以 period 为周期的周期性任务
         */
        ScheduledFutureTask(Runnable r, V result, long triggerTime,
                long period, long sequenceNumber) {
            super(r, result);
            this.time = triggerTime;
            this.period = period;
            this.sequenceNumber = sequenceNumber;
        }

        /**
         * 创建一个在 triggerTime 执行的一次性任务
         */
        ScheduledFutureTask(Callable<V> callable, long triggerTime,
                long sequenceNumber) {
            super(callable);
            this.time = triggerTime;
            this.period = 0;
            this.sequenceNumber = sequenceNumber;
        }

        /**
         *  读取当前任务的延时时间
         * created by ZXD at 9 Dec 2018 T 20:40:27
         * @param unit
         * @return
         */
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(time - System.nanoTime(), NANOSECONDS);
        }

        /**
         *  当前任务是否是周期性任务
         */
        @Override
        public boolean isPeriodic() {
            return period != 0;
        }

        /**
         * 计算周期性任务的下一次触发时间
         */
        private void setNextRunTime() {
            final long p = period;
            if (p > 0) {
                // 基于上次记录的时间进行延时，可能已经超时
                time += p;
            } else {
                // 基于 System.nanoTime() 进行延时
                time = triggerTime(-p);
            }
        }

        /**
         * Overrides FutureTask version so as to reset/requeue if periodic.
         */
        @Override
        public void run() {
            // 1）当前任务是否能在线程池中执行
            if (!canRunInCurrentRunState(this)) {
                // 不能执行，则将其取消
                cancel(false);
                // 2）如果不是周期性任务
            } else if (!isPeriodic()) {
                // 则执行该任务
                super.run();
                // 3）如果是周期性任务，运行任务并且重置状态
            } else if (super.runAndReset()) {
                // 计算周期性任务的下一次触发时间
                setNextRunTime();
                // 重新将任务加入到延时队列中
                reExecutePeriodic(outerTask);
            }
        }
    }

    /**
     *  基于二叉堆实现的延迟优先级队列，队列元素只能是 RunnableScheduledFuture 实例。
     */
    static class DelayedWorkQueue extends AbstractQueue<Runnable>
    implements BlockingQueue<Runnable> {

        // 初始容量
        private static final int INITIAL_CAPACITY = 16;
        // 保持元素的数组
        private RunnableScheduledFuture<?>[] queue =
                new RunnableScheduledFuture<?>[INITIAL_CAPACITY];
        // 互斥锁
        private final ReentrantLock lock = new ReentrantLock();
        // 元素总数
        private int size;

        /**
         *  在队列头部阻塞等待任务的线程
         */
        private Thread leader;

        /**
         *  是否有任务可用
         */
        private final Condition available = lock.newCondition();
    }

    void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        // 当前任务是否能在线程池中运行
        if (canRunInCurrentRunState(task)) {
            // 将任务加入到延时队列中
            super.getQueue().add(task);
            // 又进行一次判断，如果不能运行目标任务则尝试从延时队列中删除它
            if (canRunInCurrentRunState(task) || !remove(task)) {
                ensurePrestart();
                return;
            }
        }
        // 任务不能运行，则将其取消
        task.cancel(false);
    }

延时执行一次性任务

    /**
     *  在指定的延时后执行目标任务
     */
    @Override
    public ScheduledFuture<?> schedule(Runnable command,
            long delay,
            TimeUnit unit) {
        if (command == null || unit == null) {
            throw new NullPointerException();
        }
        // 创建一个单次延时任务
        final RunnableScheduledFuture<Void> t = decorateTask(command,
                new ScheduledFutureTask<Void>(command, null,
                        triggerTime(delay, unit),
                        sequencer.getAndIncrement()));
        // 加入延时队列中执行
        delayedExecute(t);
        return t;
    }

    private void delayedExecute(RunnableScheduledFuture<?> task) {
        // 线程池处于 SHUTDOWN 及以上状态
        if (isShutdown()) {
            // 拒绝执行任务
            reject(task);
        } else {
            // 将任务加入延时优先级队列
            super.getQueue().add(task);
            /**
             * 当前任务不能执行 && 将其从延时队列中移除成功
             */
            if (!canRunInCurrentRunState(task) && remove(task)) {
                // 则取消该任务
                task.cancel(false);
            } else {
                /**
                 * 尝试启动一个工作者线程来处理延时任务
                 * 1）当前工作者线程 < 核心线程数
                 * 2）当前工作者线程 == 0
                 */
                ensurePrestart();
            }
        }
    }

    /**
     *  是否能在当前线程池状态下运行
     */
    boolean canRunInCurrentRunState(RunnableScheduledFuture<?> task) {
        // 线程池处于 RUNNING 状态，则允许运行
        if (!isShutdown()) {
            return true;
        }
        // 线程池已经停止，则不允许运行
        if (isStopped()) {
            return false;
        }
        /**
         * 线程池处于 SHUTDOWN 状态正在停止
         * 1）当前任务是周期任务，continueExistingPeriodicTasksAfterShutdown 默认为 false
         * 2）当前任务是一次性任务，executeExistingDelayedTasksAfterShutdown 默认为 false
         *  如果任务已经超时，则执行它。
         */
        return task.isPeriodic()
                ? continueExistingPeriodicTasksAfterShutdown
                        : executeExistingDelayedTasksAfterShutdown
                        || task.getDelay(NANOSECONDS) <= 0;
    }

    /**
     *  尝试启动一个工作者线程来处理延时任务
     */
    void ensurePrestart() {
        final int wc = ThreadPoolExecutor.workerCountOf(ctl.get());
        if (wc < corePoolSize) {
            addWorker(null, true);
        } else if (wc == 0) {
            addWorker(null, false);
        }
    }

延时执行周期性任务

• 在以 unit 为单位的 initialDelay 延时后执行第一次任务，
  
  并在 initialDelay + period，initialDelay + 2 * period 等时间点周期性执行。
  
  如果任务执行时间超出 period，则下次任务会立即开始执行。

    /**
     *  在以 unit 为单位的 initialDelay 延时后执行第一次任务，并在
     *  initialDelay + period，initialDelay + 2 * period 等时间点周期性执行
     */
    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
            long initialDelay,
            long period,
            TimeUnit unit) {
        // 任务和时间单位不能为 null
        if (command == null || unit == null) {
            throw new NullPointerException();
        }
        // 执行周期必须 > 0
        if (period <= 0L) {
            throw new IllegalArgumentException();
        }
        final ScheduledFutureTask<Void> sft =
                new ScheduledFutureTask<>(command,
                        null,
                        triggerTime(initialDelay, unit),
                        unit.toNanos(period),
                        sequencer.getAndIncrement());
        final RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }

• 在以 unit 为单位的 initialDelay 延时后执行第一次任务，
  
  并在当次任务执行完成之后在 delay 延时之后再次执行。

    /**
     *  在以 unit 为单位的 initialDelay 延时后执行第一次任务，并在当次任务执行完成之后
     *  在 delay 延时之后再次执行。
     */
    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
            long initialDelay,
            long delay,
            TimeUnit unit) {
        if (command == null || unit == null) {
            throw new NullPointerException();
        }
        if (delay <= 0L) {
            throw new IllegalArgumentException();
        }
        final ScheduledFutureTask<Void> sft =
                new ScheduledFutureTask<>(command,
                        null,
                        triggerTime(initialDelay, unit),
                        -unit.toNanos(delay),
                        sequencer.getAndIncrement());
        final RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }