Java中调度线程池ScheduledThreadPoolExecutor原理探究

类关系

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {}

可以看出，ScheduledThreadPoolExecutor继承了ThreadPoolExecutor类，实现了ScheduledExecutorService接口。其构造函数如下：

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

构造函数中调用了super方法，super方法其实是ThreadPoolExecutor类的构造函数，如下：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

从上述关系看出，ScheduledThreadPoolExecutor其实是ThreadPoolExecutor线程池衍生品，使用了DelayedWorkQueue线程池队列，线程池容量无边界，添加了延迟后运行命令，或者定期执行命令等属性。

一个例子

import java.util.concurrent.*;

public class ScheduleTest {

    public static void main(String[] args) throws InterruptedException,ExecutionException{

        ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(10);

        executScheduleWithFixedDelay(executorService);

        executScheduleAtFixedRate(executorService);

        executSchedule(executorService);

        System.out.println("over");

        executorService.shutdown();
    }

    // 间隔3秒执行一次
    public static void executScheduleWithFixedDelay(ScheduledExecutorService executorService) throws InterruptedException,ExecutionException{

        ScheduledFuture<?> result = executorService.scheduleWithFixedDelay(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("scheduleWithFixedDelay-" + System.currentTimeMillis());
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },1000, 3000,TimeUnit.MILLISECONDS
        );

        result.get();
    }

    // 线程在第4秒开始执行
    public static void executScheduleAtFixedRate(ScheduledExecutorService executorService) throws InterruptedException,ExecutionException{

        ScheduledFuture<?> result = executorService.scheduleAtFixedRate(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("scheduleAtFixedRate-" + System.currentTimeMillis());
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },1000, 4000,TimeUnit.MILLISECONDS
        );

        result.get();
    }

    // 线程延迟4秒执行,仅执行一次
    public static void executSchedule(ScheduledExecutorService executorService) throws InterruptedException,ExecutionException{

        ScheduledFuture<?> result = executorService.schedule(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("schedule-" + System.currentTimeMillis());
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                },4000, TimeUnit.MILLISECONDS
        );

        result.get();
    }
}

例子中也可以调用Executors的静态方法获取ScheduledExecutorService实例：

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();

这个例子引出了ScheduledThreadPoolExecutor调度线程池启动的3方法：

• scheduleWithFixedDelay：线程延迟执行。
• scheduleAtFixedRate：线程依照时间表执行，如果到指定时间点线程还没有执行完毕，则放弃该时间点，执行完毕后继续执行下一个线程。
• schedule：创建并执行在给定延迟后启用的一次性操作。

相关方法执行结果参考：

源码说明

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;
}

任务添加到队列后，工作线程会从队列获取并移除到期的元素，然后执行run方法，所以下面看看ScheduledFutureTask的run方法如何实现定时调度的。

其中ScheduledFutureTask封装定时任务内部类，重点关注其run方法。

ScheduledFutureTask(Runnable r, V result, long ns, long period) {
            super(r, result);
            this.time = ns;
            this.period = period;
            this.sequenceNumber = sequencer.getAndIncrement();
        }

public void run() {
            boolean periodic = isPeriodic();
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            //仅执行一次
            else if (!periodic)
                ScheduledFutureTask.super.run();
            //定时任务
            else if (ScheduledFutureTask.super.runAndReset()) {
                setNextRunTime();
                //重新加入该任务到delay队列
                reExecutePeriodic(outerTask);
            }
        }

定时调度是先从队列获取任务然后执行，然后在重新设置任务时间，在把任务放入队列实现的。

如果任务执行时间大于delay时间则等任务执行完毕后的delay时间后在次调用任务，不会同一个任务并发执行。

scheduleAtFixedRate、schedule方法原理如出一辙。

参考

1、http://ifeve.com/33981-2/

2、类 ScheduledThreadPoolExecutor