Java并发——ScheduledThreadPoolExecutor分析-优快云博客

本文详细剖析了ScheduledThreadPoolExecutor的工作原理，包括其继承关系、构造方法、主要方法及内部类的作用。通过示例展示了如何使用scheduleAtFixedRate和scheduleWithFixedDelay方法执行周期性任务，并解释了它们之间的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ScheduledThreadPoolExecutor分析

从图中我们可以看到ScheduledThreadPoolExecutor继承ThreadPoolExecutor实现了ScheduledExecutorService接口。它相当于提供了"延迟"和"周期执行"功能的ThreadPoolExecutor，还有两个重要内部类DelayedWorkQueue和ScheduledFutureTask

构造方法


    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }
    
    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }
    
    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), handler);
    }
    
    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory,
                                       RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory, handler);
    }
复制代码

因为其继承了ThreadPoolExecutor，调用了ThreadLocalExecutor的构造方法。当核心线程数达到corePoolSize，会将任务提交给有界阻塞队列DelayedWorkQueue。ScheduledThreadPoolExecutor线程池最大线程数为Integer.MAX_VALUE

主要方法

ScheduledThreadPoolExecutor实现了ScheduledExecutorService接口，该接口提供了如下方法:


    // 在给定延迟后，执行Runnable任务
    public ScheduledFuture schedule(Runnable command,
                                       long delay, TimeUnit unit);
    // 在给定延迟后，执行Callable任务
    public  ScheduledFuture schedule(Callable callable,
                                           long delay, TimeUnit unit);
    // 给定延迟(initialDelay)之后，随后以给定时间(period)为周期执行任务
    // 即执行将在initialDelay之后开始，然后是initialDelay+period，
    // 再是initialDelay + 2*period，依此类推
    // 
    public ScheduledFuture scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
    // 创建并执行在给定的初始延迟(initialDelay)之后首先启用的定期操作
    // 随后和下一个执行的开始之间给定的延迟(delay)
    public ScheduledFuture scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);
复制代码

第一、第二个schedule方法都是一次性操作只不过入参一个是Runnable，一个是callable

scheduleAtFixedRate、scheduleWithFixedDelay方法可以看如下示例

示例:


    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("hh:MM:ss");
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
        Runnable task1 = () -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "测试" + sdf.format(new Date()));
        };
        Runnable task2 = () -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "测试" + sdf.format(new Date()));
        };
        executorService.scheduleAtFixedRate(task1, 0, 2, TimeUnit.SECONDS);
        executorService.scheduleWithFixedDelay(task2, 0, 2, TimeUnit.SECONDS);
    }
    
    输出:
    
    pool-1-thread-2测试11:12:37
    
    pool-1-thread-2测试11:12:42
    
    
    pool-1-thread-2测试11:12:47
复制代码

周期间隔2秒，任务耗时3秒
scheduleAtFixedRate方法:
1.若任务耗时超过周期间隔，则需要等待上个任务完成下个任务才能执行
2.若任务耗时小于周期间隔，则下个任务按周期间隔执行任务
scheduleWithFixedDelay方法:
1.下任务等到上个任务执行完成+周期间隔之后才执行任务

schedule方法
逻辑处理相差不多，以schedule方法为例分析


    public  ScheduledFuture schedule(Callable callable,
                                           long delay,
                                           TimeUnit unit) {
        if (callable == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture t = decorateTask(callable,
            new ScheduledFutureTask(callable,
                                       triggerTime(delay, unit)));
        delayedExecute(t);
        return t;
    }
复制代码

先参数校验，再构造task，最后调用delayedExecute()方法延迟执行任务


    private void delayedExecute(RunnableScheduledFuture task) {
        // 判断线程池是否处于RUNNING状态，不处于则根据相应拒绝策略拒绝任务
        if (isShutdown())
            reject(task);
        else {
            // 往阻塞队列中添加任务
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                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);
}
复制代码


复制代码

复制代码

ensurePrestart主要调用了addWorker方法，此方法主要做了两件事:
1.循环CAS将线程池中的线程数加一
2.新建一个线程并启用

当线程执行任务，都会调用到任务的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);
            }
        }
复制代码

1.先判断该任务是否可以执行，若不能执行则调用cancel方法取消
2.再判断是否是周期性任务，若不是直接执行
3.最后调用runAndReset方法执行任务并重置，setNextRunTime方法设置任务下次的执行时间，reExecutePeriodic方法重新把任务添加到队列中.


    private void setNextRunTime() {
        long p = period;
        if (p > 0)
            time += p;
        else
            time = triggerTime(-p);
    }
    
    void reExecutePeriodic(RunnableScheduledFuture task) {
        if (canRunInCurrentRunState(true)) {
            super.getQueue().add(task);
            if (!canRunInCurrentRunState(true) && remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }
复制代码

DelayedWorkQueue

ScheduledThreadPoolExecutor是把任务添加到DelayedWorkQueue中，它是一个基于堆的数据结构，通过ScheduledFutureTask的compareTo方法比较大小，小的排在前面，大的排在后面


    public int compareTo(Delayed other) {
        if (other == this) // compare zero if same object
            return 0;
        if (other instanceof ScheduledFutureTask) {
            ScheduledFutureTask x = (ScheduledFutureTask)other;
            long diff = time - x.time;
            if (diff < 0)
                return -1;
            else if (diff > 0)
                return 1;
            else if (sequenceNumber < x.sequenceNumber)
                return -1;
            else
                return 1;
        }
        long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
        return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
    }
复制代码

首先按照time排序，time小的排在前面，大的排在后面，若time相同，则使用sequenceNumber排序，小的排在前面，大的排在后面