搞懂Spring任务执行器和调度器模型

写bug写bug2025-08-11 16:22

在日常开发过程中，如果想要处理长时间运行的任务，对于任何应用程序开发而言都不是一件容易的事情。有时候，需要异步执行任务或在特定延迟之后执行任务，这可以通过 Spring 的任务执行和任务调度来完成。Spring 框架通过 TaskExecutor 和 TaskScheduler 这两个接口引入了对异步执行和任务调度的抽象。让我们一起来看一下。

Spring 任务执行器

在介绍 Spring 任务执行器之前，要先引出 JDK 中的一个基础并发编程组件，即 Executor 。所谓的 Executor，本质上是在所有内部线程任务执行过程上提供了一个抽象层，并管理线程的整个并发执行流。Executor 是执行任务的入口， JDK 为 Executor 提供了以下三个基本接口，即 Executor、ExecutorService 和 ScheduledExecutorService。

Spring 提供 TaskExecutor 接口作为 Executor 的抽象。TaskExecutor 的实现类有很多，它们提供了针对异步执行过程的各种支持。

接下来，以最基础的 SimpleAsyncTaskExecutor为例，来看看在 Spring 应用程序中执行任务的具体实现过程。

TaskExecutor 应用方式

SimpleAsyncTaskExecutor 为每个任务创建一个新线程，并以异步方式运行，它实现了 AsyncTaskExecutor 接口。可以通过以下方式在 Spring 应用程序中注入一个 SimpleAsyncTaskExecutor。

java 复制代码 
@Bean
AsyncTaskExecutor taskExecutor() {
    SimpleAsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
    return taskExecutor;
}

然后，可以构建一个 AsyncTask，并通过 SimpleAsyncTaskExecutor 来异步执行任务。

java 复制代码 
public class AsyncTask {
    @Autowired
    private AsyncTaskExecutor executor;
    public void runTasks() throws Exception {
        for (int i = 1; i <= 5; i++) {
           Runnable task = new SpringTask(" " + i);
           executor.execute(task);
        }
    }
}

这里创建了一个自定义的 SpringTask，这是 JDK 中 Runnable 接口的实现类。

typescript 复制代码 
public class SpringTask implements Runnable {
    privatestaticfinal Logger LOGGER = Logger.getLogger(Task.class);
    private String taskNumber;
    public SpringTask(String taskNumber) {
        this.taskNumber = taskNumber;
    }
    @Override
    public void run() {
        LOGGER.info(Thread.currentThread().getName() + ", Execute Task = " + taskNumber);
        taskProcess();
        LOGGER.info(Thread.currentThread().getName() + ", End");
    }
    private void taskProcess() {
        try {
           Thread.sleep(2000);
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
    }
}

这里通过让执行线程睡眠 2 秒钟的方式来模拟任务的执行时间，并把执行的过程通过日志的方式打印出来。执行这段代码，会在控制台中得到如下输出：

ini 复制代码 
INFO  SpringTask:15 - SimpleAsyncTaskExecutor-3, Execute Task =  3
INFO  SpringTask:15 - SimpleAsyncTaskExecutor-1, Execute Task =  1
INFO  SpringTask:15 - SimpleAsyncTaskExecutor-2, Execute Task =  2
INFO  SpringTask:15 - SimpleAsyncTaskExecutor-5, Execute Task =  5
INFO  SpringTask:15 - SimpleAsyncTaskExecutor-4, Execute Task =  4
INFO  SpringTask:17 - SimpleAsyncTaskExecutor-2, End
INFO  SpringTask:17 - SimpleAsyncTaskExecutor-4, End
INFO  SpringTask:17 - SimpleAsyncTaskExecutor-3, End
INFO  SpringTask:17 - SimpleAsyncTaskExecutor-5, End
INFO  SpringTask:17 - SimpleAsyncTaskExecutor-1, End

显然，基于 SimpleAsyncTaskExecutor，任务与线程之间应该是一对一的执行关系。

TaskExecutor 运行原理

介绍完 Spring 任务执行器的使用方式之后，来进一步分析它的实现原理。同样，还是以前面介绍的 SimpleAsyncTaskExecutor 为例展开讨论。SimpleAsyncTaskExecutor 的类层结构如图所示：

这里的 TaskExecutor 和 AsyncTaskExecutor 都比较好理解，直接看它们的接口定义，如下所示：

java 复制代码 
public interface TaskExecutor extends Executor {
    @Override
    void execute(Runnable task);
}
public interface AsyncTaskExecutor extends TaskExecutor {
    void execute(Runnable task, long startTimeout);
    Future<?> submit(Runnable task);
    <T> Future<T> submit(Callable<T> task);
}

AsyncListenableTaskExecutor 又扩展了 AsyncTaskExecutor，添加了可以返回 ListenableFuture 的方法，ListenableFuture 是 JDK 中 Future 接口的子接口，可用于在任务提交后添加回调。

接下来，来看 AsyncListenableTaskExecutor 中的 execute 方法，如下所示：

java 复制代码 
@Override
public void execute(Runnable task, long startTimeout) {
        Assert.notNull(task, "Runnable must not be null");
        //使用包装器包装任务
        Runnable taskToUse = (this.taskDecorator != null ? this.taskDecorator.decorate(task) : task);
        //启用限流器来执行任务
        if (isThrottleActive() && startTimeout > TIMEOUT_IMMEDIATE) {
           this.concurrencyThrottle.beforeAccess();
           doExecute(new ConcurrencyThrottlingRunnable(taskToUse));
        }
        //不启用限流器来执行任务
        else {
           doExecute(taskToUse);
        }
}

这里引出了限流器的概念，限流器的作用是线程执行的并发度达到阈值则会让后续的线程处于阻塞等待。这是 Spring TaskExecutor 设计上的一个亮点，基本思想如图所示：

结合图示，不难看出限流器是在线程执行之前进行并发限制的判断，如果需要限流就阻塞线程。而如果任务执行完成后，那就唤醒正在等待的线程继续执行任务。

而真正执行任务的 doExecute() 方法比较简单，单独从线程工厂 ThreadFactory 获取线程，或者直接创建一个新的线程进行执行即可，如下所示：

arduino 复制代码 
protected void doExecute(Runnable task) {
    Thread thread = (this.threadFactory != null ? this.threadFactory.newThread(task) : createThread(task));
    thread.start();
}

Spring 任务调度器

介绍完 Spring 任务执行器，接下来讨论 Spring 任务调度器。有时，我们需要以固定的时间间隔执行任务，就可以通过任务调度器来实现。基于 Spring，将看到如何使用一些注解来对任务进行调度。

TaskScheduler 应用方式

在 Spring 中，可以借助@EnableScheduling 注解来启用任务调度。

less 复制代码 
@Configuration
@EnableScheduling
public class SpringSchedulingExample

一旦启用了任务调度，Spring 将自动注册一个内部 BeanPostProcessor，它将在 Spring 管理的 Bean 上找到添加了@Scheduled 注解的方法。@Scheduled 注解的使用方法如下所示：

typescript 复制代码 
@Scheduled(fixedDelay = 2000)
public void scheduledTask() {
     LOGGER.info("Execute task " + new Date());
}

在这里，使用@Scheduled 注解为 scheduledTask() 设置了调度任务，即通过 fixedDelay 属性每两秒执行一次该方法。执行该方法，可以在控制台上看到如下信息：

sql 复制代码 
INFO  SpringSchedulingExample:17 - Execute task Sat May 01 20:06:11 CST 2021
INFO  SpringSchedulingExample:17 - Execute task Sat May 01 20:06:13 CST 2021
INFO  SpringSchedulingExample:17 - Execute task Sat May 01 20:06:15 CST 2021
INFO  SpringSchedulingExample:17 - Execute task Sat May 01 20:06:17 CST 2021
INFO  SpringSchedulingExample:17 - Execute task Sat May 01 20:06:19 CST 2021

当然，还可以使用其他调度属性，@Scheduled 注解的完整定义如下所示：

less 复制代码 
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(Schedules.class)
public @interface Scheduled {
    //cron 表达式
    String cron() default "";
    //由 cron 表达式进行解析的时间区域
    String zone() default "";
    //固定延迟时间
    long fixedDelay() default -1;
    //字符串形式的固定延迟时间
    String fixedDelayString() default "";
    //固定周期
    long fixedRate() default -1;
    //字符串形式的固定周期
    String fixedRateString() default "";
    //初始延迟时间
    long initialDelay() default -1;
    //字符串形式的初始延迟时间
    String initialDelayString() default "";
}

这些属性都很简单，唯一需要说明一下的是 fixedRate。举个例子，如果在某个方法上设置 fiexdRate=3000，而执行该方法所花的时间是一秒，那么两秒后就会再次执行该方法。

TaskScheduler 运行原理

在 Spring 的 TaskScheduler 出现之前，可以使用 JDK 中的 Timer 或第三方的 Quartz 组件类实现调度功能。而 TaskScheduler 的核心优势就是为开发人员提供了一种抽象，使得执行定时任务的代码不需要指定特定的定时框架。TaskScheduler 接口的定义如下所示：

arduino 复制代码 
public interface TaskScheduler {
    ScheduledFuture<?> schedule(Runnable task, Trigger trigger);
    ScheduledFuture<?> schedule(Runnable task, Date startTime);
    ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period);
    ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period);
    ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay);
    ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay);
}

TaskScheduler 中各个方法的含义可以结合@Scheduled 注解的说明进行理解，而这些方法都返回了一个 JDK 中的 ScheduledFuture 对象，该对象是对 Future 的扩展。

在 Spring 中，TaskScheduler 接口的代表性实现就是 ThreadPoolTaskScheduler，其类层结构如图所示：

翻阅 ThreadPoolTaskScheduler 类的源代码，发现在该类中存在如下所示的一个变量定义。

arduino 复制代码 
private ScheduledExecutorService scheduledExecutor;

在前面介绍 JDK Executor 时，已经引出了 ScheduledExecutorService，它为开发人员提供了各种调度方法。所以，看到这里，不难理解，ThreadPoolTaskScheduler 实际上就是将各种调度操作委托给了这个 ScheduledExecutorService。通过如下所示的 schedule 方法实现过程印证了这一点。

typescript 复制代码 
@Override
public ScheduledFuture<?> schedule(Runnable task, Date startTime) {
        ScheduledExecutorService executor = getScheduledExecutor();
        long initialDelay = startTime.getTime() - System.currentTimeMillis();
        try {
           return executor.schedule(errorHandlingTask(task, false), initialDelay, TimeUnit.MILLISECONDS);
        }
        catch (RejectedExecutionException ex) {
           throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
        }
}

可以看到，这里首先获取一个 ScheduledExecutorService，然后通过它的 schedule 方法完成调度。而 ScheduledExecutorService 的创建过程也很简单，如下所示：

arduino 复制代码 
protected ScheduledExecutorService createExecutor(
           int poolSize, ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {
    return new ScheduledThreadPoolExecutor(poolSize, threadFactory, rejectedExecutionHandler);
}

这样，就把 JDK 中的 ScheduledExecutorService 和 Spring 中的 TaskScheduler 关联了起来，从而完成了对任务调度过程的剖析。

总结

针对并发编程，我们可以使用 JDK 所提供的 Thread 类和 Runnable 接口来创建和管理多线程。但由于这些技术组件过于底层，所以在日常开发过程中，我一般不推荐你使用它们来创建多线程应用程序。

而 JDK 并发包中的 Executor 等组件虽然经过高度抽象，为开发人员提供了高层次的 API，但由于并发编程涉及到多线程之间的协作和交互，合理使用这些组件对开发人员的要求也很高。

Spring 框架充分考虑到了这些问题，并结合常见的应用场景提供了任务执行器和任务调度器组件。在今天的内容中，我们从应用方法 和 运行原理这两个维度对这两款技术组件进行了详细地分析，帮助你在开发过程中能够更好地实现各种并发编程需求。

相关推荐
bobz965几秒前
virtio-networking 5: 介绍 vDPA kernel framework
后端
橙子家32 分钟前
接口 IResultFilter、IAsyncResultFilter 的简介和用法示例（.net）
后端
CYRUS_STUDIO1 小时前
一步步带你移植 FART 到 Android 10，实现自动化脱壳
android·java·逆向
bobz9651 小时前
Virtio-networking: 2019 总结 2020展望
后端
AntBlack1 小时前
每周学点 AI ： 在 Modal 上面搭建一下大模型应用
后端
练习时长一年1 小时前
Spring代理的特点
java·前端·spring
G探险者1 小时前
常见线程池的创建方式及应用场景
后端
CYRUS_STUDIO1 小时前
FART 主动调用组件深度解析：破解 ART 下函数抽取壳的终极武器
android·java·逆向
bobz9651 小时前
virtio-networking 4： 介绍 vDPA 1
后端
MisterZhang6662 小时前
Java使用apache.commons.math3的DBSCAN实现自动聚类
java·人工智能·机器学习·自然语言处理·nlp·聚类
热门推荐
01不再让Windows更新！&Edge游戏助手卸载及关闭自动更新02奈飞工厂官网，国内Netflix影视在线看|中文网页电脑版入口03UV安装并设置国内源04KGG转MP3工具|非KGM文件|解密音频05Xget：下一代开源资源获取加速引擎，让你的文件下载、储存库克隆和镜像拉取快如闪电06Linux下V2Ray安装配置指南07Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code08蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接09【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）10突破百度网盘的下载限速，两种方法教会你【超详细】