ScheduledThreadPoolExecutor实现延时及定时任务的步骤

ScheduledThreadPoolExecutor提供的两个方法来完成延迟及定时执行任务

scheduleAtFixedRate及scheduleWithFixedDelay

大致执行步骤：

1）创建task任务

2）将任务加入到延迟队列

3）启用线程通过getTask方法从队列中获取任务

4）延迟队列中的take方法获取任务时，会根据等待时间阻塞任务；

针对scheduleAtFixedRate源码分析：

public ScheduledFuture<?> scheduleAtFixedRate(
                                              // 要执行的任务
                                              Runnable command,
                                              // 第一次延迟执行时间
                                              long initialDelay,
                                              // 两次执行相隔时间
                                              long period,
                                              // 时间单位
                                              TimeUnit unit) {
    if (command == null || unit == null)
        throw new NullPointerException();
    if (period <= 0L)
        throw new IllegalArgumentException();
        
    // 创建一个task任务
    ScheduledFutureTask<Void> sft =
        new ScheduledFutureTask<Void>(command,
                                      null,
                                      triggerTime(initialDelay, unit),
                                      unit.toNanos(period),
                                      sequencer.getAndIncrement());
    RunnableScheduledFuture<Void> t = decorateTask(command, sft);
    sft.outerTask = t;
    // 执行task任务
    delayedExecute(t);
    return t;
}

private void delayedExecute(RunnableScheduledFuture<?> task) {
    if (isShutdown())
        reject(task);
    else {
        // 将任务加入延迟队列
        // super.getQueue()得到的就是DelayedWorkQueue，
        // 这是ScheduledThreadPoolExecutor初始化时默认的阻塞队列
        super.getQueue().add(task);
        if (!canRunInCurrentRunState(task) && remove(task))
            task.cancel(false);
        else
            // 启动前准备工作
            ensurePrestart();
    }
}

void ensurePrestart() {
    int wc = workerCountOf(ctl.get());
    // 线程池里边有没有线程，没有就创建一个，核心或非核心线程
    if (wc < corePoolSize)
        addWorker(null, true);
    else if (wc == 0)
        addWorker(null, false);
}

public RunnableScheduledFuture<?> take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            RunnableScheduledFuture<?> first = queue[0];
            if (first == null)
                available.await();
            else {
                //等待时长
                long delay = first.getDelay(NANOSECONDS);
                if (delay <= 0L)
                    return finishPoll(first);
                first = null; // don't retain ref while waiting
                if (leader != null)
                    available.await();
                else {
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        //阻塞指定时长任务
                        available.awaitNanos(delay);
                    } finally {
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && queue[0] != null)
            available.signal();
        lock.unlock();
    }
}

scheduleAtFixedRate与scheduleWithFixedDelay

两个方法都可以延迟及定时执行任务，但是有细微的差别：

scheduleAtFixedRate：与任务执行的时间长短无关，从任务开始执行计时，指定间隔时间后执行下一次任务；

scheduleWithFixedDelay：与任务执行的时间长短有关，从任务执行结束后开始及时，指定间隔时间后执行下一个任务；

执行一个定时任务的大致步骤就是这样，后续有时间补充个demo；