springboot中@scheduled的开关机制（针对全局定时任务）

最新推荐文章于 2026-04-18 12:09:22 发布
原创 最新推荐文章于 2026-04-18 12:09:22 发布 · 7k 阅读 · 11 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
在SpringBoot中，利用@scheduled实现定时任务时，如何实现在不同环境中控制所有定时任务的开启或关闭？本文介绍一种解决方案，通过了解ScheduledTaskRegistrar类，清空扫描的定时任务类别，达到统一控制的效果。

 

 

目前遇到的问题：

我们可以在springboot中使用@scheduled注解来完成定时任务。我现在有两台机器部署同一个应用。

一台希望开启全部的定时器，另一台希望关闭全部定时器，考虑到上一篇博客

（https://blog.csdn.net/qq_37826571/article/details/105097249）只能对一个定时任务进行开关，我不能把之前的定时任务都分离

出来一个个的改代码，太麻烦了，怎么办？

解决方案：

那就要从源头去解决，这里大家要了解ScheduledTaskRegistrar 这个类，我这里为了 大家方便，给大家展示出来这个类。

 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.scheduling.config;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.concurrent.ConcurrentTaskScheduler;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

public class ScheduledTaskRegistrar implements InitializingBean, DisposableBean {
    private TaskScheduler taskScheduler;
    private ScheduledExecutorService localExecutor;
    private List<TriggerTask> triggerTasks;
    private List<CronTask> cronTasks;
    private List<IntervalTask> fixedRateTasks;
    private List<IntervalTask> fixedDelayTasks;
    private final Map<Task, ScheduledTask> unresolvedTasks = new HashMap(16);
    private final Set<ScheduledTask> scheduledTasks = new LinkedHashSet(16);

    public ScheduledTaskRegistrar() {
    }

    public void setTaskScheduler(TaskScheduler taskScheduler) {
        Assert.notNull(taskScheduler, "TaskScheduler must not be null");
        this.taskScheduler = taskScheduler;
    }

    public void setScheduler(Object scheduler) {
        Assert.notNull(scheduler, "Scheduler object must not be null");
        if (scheduler instanceof TaskScheduler) {
            this.taskScheduler = (TaskScheduler)scheduler;
        } else {
            if (!(scheduler instanceof ScheduledExecutorService)) {
                throw new IllegalArgumentException("Unsupported scheduler type: " + scheduler.getClass());
            }

            this.taskScheduler = new ConcurrentTaskScheduler((ScheduledExecutorService)scheduler);
        }

    }

    public TaskScheduler getScheduler() {
        return this.taskScheduler;
    }

    public void setTriggerTasks(Map<Runnable, Trigger> triggerTasks) {
        this.triggerTasks = new ArrayList();
        Iterator var2 = triggerTasks.entrySet().iterator();

        while(var2.hasNext()) {
            Entry<Runnable, Trigger> task = (Entry)var2.next();
            this.addTriggerTask(new TriggerTask((Runnable)task.getKey(), (Trigger)task.getValue()));
        }

    }

    public void setTriggerTasksList(List<TriggerTask> triggerTasks) {
        this.triggerTasks = triggerTasks;
    }

    public List<TriggerTask> getTriggerTaskList() {
        return this.triggerTasks != null ? Collections.unmodifiableList(this.triggerTasks) : Collections.emptyList();
    }

    public void setCronTasks(Map<Runnable, String> cronTasks) {
        this.cronTasks = new ArrayList();
        Iterator var2 = cronTasks.entrySet().iterator();

        while(var2.hasNext()) {
            Entry<Runnable, String> task = (Entry)var2.next();
            this.addCronTask((Runnable)task.getKey(), (String)task.getValue());
        }

    }

    public void setCronTasksList(List<CronTask> cronTasks) {
        this.cronTasks = cronTasks;
    }

    public List<CronTask> getCronTaskList() {
        return this.cronTasks != null ? Collections.unmodifiableList(this.cronTasks) : Collections.emptyList();
    }

    public void setFixedRateTasks(Map<Runnable, Long> fixedRateTasks) {
        this.fixedRateTasks = new ArrayList();
        Iterator var2 = fixedRateTasks.entrySet().iterator();

        while(var2.hasNext()) {
            Entry<Runnable, Long> task = (Entry)var2.next();
            this.addFixedRateTask((Runnable)task.getKey(), (Long)task.getValue());
        }

    }

    public void setFixedRateTasksList(List<IntervalTask> fixedRateTasks) {
        this.fixedRateTasks = fixedRateTasks;
    }

    public List<IntervalTask> getFixedRateTaskList() {
        return this.fixedRateTasks != null ? Collections.unmodifiableList(this.fixedRateTasks) : Collections.emptyList();
    }

    public void setFixedDelayTasks(Map<Runnable, Long> fixedDelayTasks) {
        this.fixedDelayTasks = new ArrayList();
        Iterator var2 = fixedDelayTasks.entrySet().iterator();

        while(var2.hasNext()) {
            Entry<Runnable, Long> task = (Entry)var2.next();
            this.addFixedDelayTask((Runnable)task.getKey(), (Long)task.getValue());
        }

    }

    public void setFixedDelayTasksList(List<IntervalTask> fixedDelayTasks) {
        this.fixedDelayTasks = fixedDelayTasks;
    }

    public List<IntervalTask> getFixedDelayTaskList() {
        return this.fixedDelayTasks != null ? Collections.unmodifiableList(this.fixedDelayTasks) : Collections.emptyList();
    }

    public void addTriggerTask(Runnable task, Trigger trigger) {
        this.addTriggerTask(new TriggerTask(task, trigger));
    }

    public void addTriggerTask(TriggerTask task) {
        if (this.triggerTasks == null) {
            this.triggerTasks = new ArrayList();
        }

        this.triggerTasks.add(task);
    }

    public void addCronTask(Runnable task, String expression) {
        this.addCronTask(new CronTask(task, expression));
    }

    public void addCronTask(CronTask task) {
        if (this.cronTasks == null) {
            this.cronTasks = new ArrayList();
        }

        this.cronTasks.add(task);
    }

    public void addFixedRateTask(Runnable task, long interval) {
        this.addFixedRateTask(new IntervalTask(task, interval, 0L));
    }

    public void addFixedRateTask(IntervalTask task) {
        if (this.fixedRateTasks == null) {
            this.fixedRateTasks = new ArrayList();
        }

        this.fixedRateTasks.add(task);
    }

    public void addFixedDelayTask(Runnable task, long delay) {
        this.addFixedDelayTask(new IntervalTask(task, delay, 0L));
    }

    public void addFixedDelayTask(IntervalTask task) {
        if (this.fixedDelayTasks == null) {
            this.fixedDelayTasks = new ArrayList();
        }

        this.fixedDelayTasks.add(task);
    }

    public boolean hasTasks() {
        return !CollectionUtils.isEmpty(this.triggerTasks) || !CollectionUtils.isEmpty(this.cronTasks) || !CollectionUtils.isEmpty(this.fixedRateTasks) || !CollectionUtils.isEmpty(this.fixedDelayTasks);
    }

    public void afterPropertiesSet() {
        this.scheduleTasks();
    }

    protected void scheduleTasks() {
        if (this.taskScheduler == null) {
            this.localExecutor = Executors.newSingleThreadScheduledExecutor();
            this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
        }

        Iterator var1;
        if (this.triggerTasks != null) {
            var1 = this.triggerTasks.iterator();

            while(var1.hasNext()) {
                TriggerTask task = (TriggerTask)var1.next();
                this.addScheduledTask(this.scheduleTriggerTask(task));
            }
        }

        if (this.cronTasks != null) {
            var1 = this.cronTasks.iterator();

            while(var1.hasNext()) {
                CronTask task = (CronTask)var1.next();
                this.addScheduledTask(this.scheduleCronTask(task));
            }
        }

        IntervalTask task;
        if (this.fixedRateTasks != null) {
            var1 = this.fixedRateTasks.iterator();

            while(var1.hasNext()) {
                task = (IntervalTask)var1.next();
                this.addScheduledTask(this.scheduleFixedRateTask(task));
            }
        }

        if (this.fixedDelayTasks != null) {
            var1 = this.fixedDelayTasks.iterator();

            while(var1.hasNext()) {
                task = (IntervalTask)var1.next();
                this.addScheduledTask(this.scheduleFixedDelayTask(task));
            }
        }

    }

    private void addScheduledTask(ScheduledTask task) {
        if (task != null) {
            this.scheduledTasks.add(task);
        }

    }

    public ScheduledTask scheduleTriggerTask(TriggerTask task) {
        ScheduledTask scheduledTask = (ScheduledTask)this.unresolvedTasks.remove(task);
        boolean newTask = false;
        if (scheduledTask == null) {
            scheduledTask = new ScheduledTask();
            newTask = true;
        }

        if (this.taskScheduler != null) {
            scheduledTask.future = this.taskScheduler.schedule(task.getRunnable(), task.getTrigger());
        } else {
            this.addTriggerTask(task);
            this.unresolvedTasks.put(task, scheduledTask);
        }

        return newTask ? scheduledTask : null;
    }

    public ScheduledTask scheduleCronTask(CronTask task) {
        ScheduledTask scheduledTask = (ScheduledTask)this.unresolvedTasks.remove(task);
        boolean newTask = false;
        if (scheduledTask == null) {
            scheduledTask = new ScheduledTask();
            newTask = true;
        }

        if (this.taskScheduler != null) {
            scheduledTask.future = this.taskScheduler.schedule(task.getRunnable(), task.getTrigger());
        } else {
            this.addCronTask(task);
            this.unresolvedTasks.put(task, scheduledTask);
        }

        return newTask ? scheduledTask : null;
    }

    public ScheduledTask scheduleFixedRateTask(IntervalTask task) {
        ScheduledTask scheduledTask = (ScheduledTask)this.unresolvedTasks.remove(task);
        boolean newTask = false;
        if (scheduledTask == null) {
            scheduledTask = new ScheduledTask();
            newTask = true;
        }

        if (this.taskScheduler != null) {
            if (task.getInitialDelay() > 0L) {
                Date startTime = new Date(System.currentTimeMillis() + task.getInitialDelay());
                scheduledTask.future = this.taskScheduler.scheduleAtFixedRate(task.getRunnable(), startTime, task.getInterval());
            } else {
                scheduledTask.future = this.taskScheduler.scheduleAtFixedRate(task.getRunnable(), task.getInterval());
            }
        } else {
            this.addFixedRateTask(task);
            this.unresolvedTasks.put(task, scheduledTask);
        }

        return newTask ? scheduledTask : null;
    }

    public ScheduledTask scheduleFixedDelayTask(IntervalTask task) {
        ScheduledTask scheduledTask = (ScheduledTask)this.unresolvedTasks.remove(task);
        boolean newTask = false;
        if (scheduledTask == null) {
            scheduledTask = new ScheduledTask();
            newTask = true;
        }

        if (this.taskScheduler != null) {
            if (task.getInitialDelay() > 0L) {
                Date startTime = new Date(System.currentTimeMillis() + task.getInitialDelay());
                scheduledTask.future = this.taskScheduler.scheduleWithFixedDelay(task.getRunnable(), startTime, task.getInterval());
            } else {
                scheduledTask.future = this.taskScheduler.scheduleWithFixedDelay(task.getRunnable(), task.getInterval());
            }
        } else {
            this.addFixedDelayTask(task);
            this.unresolvedTasks.put(task, scheduledTask);
        }

        return newTask ? scheduledTask : null;
    }

    public void destroy() {
        Iterator var1 = this.scheduledTasks.iterator();

        while(var1.hasNext()) {
            ScheduledTask task = (ScheduledTask)var1.next();
            task.cancel();
        }

        if (this.localExecutor != null) {
            this.localExecutor.shutdownNow();
        }

    }
}

 

我们把扫描的几个类别的Task清空 就可以了。(这里要看@Schedule 注解里 你使用的是哪个类别的Task,如果只有Cron的 ，那就只删除CronTask就可以)

如下代码：

import com.google.common.collect.Maps;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.concurrent.Executor;

@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {

    @Value("${scheduling.enabled}")
    private boolean taskSwitch;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        if(!taskSwitch){
            //清空扫描到的定时任务即可
            taskRegistrar.setTriggerTasks(Maps.newHashMap());
            taskRegistrar.setCronTasks(Maps.newHashMap());
            taskRegistrar.setFixedRateTasks(Maps.newHashMap());
            taskRegistrar.setFixedDelayTasks(Maps.newHashMap());
        }
        taskRegistrar.setScheduler(taskExecutor());
    }

    @Bean(destroyMethod = "shutdown")
    public Executor taskExecutor() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(10);
        taskScheduler.initialize();
        return taskScheduler;
    }
}

配置文件：

application.properties

# @Schedule 定时任务的开true/关false
scheduling.enabled=true

欢迎大家留言遇到的问题

如果大家觉得对这个操作的原理不是很理解，给大家推荐一个博客：

https://blog.csdn.net/a842699897/article/details/83790282

我就不写了，这个博客写的不错

qq_37826571
关注
SpringBoot定时任务动态扩展ScheduledTaskRegistrar
m0_71777195的博客
01-12 4577
本文主要介绍基于。
Springboot定时任务踩坑记录
2的32次方
03-29 3321
Springboot 2.1.3.RELEASE 定时任务踩坑记录
定时任务相关：ScheduledTaskRegistrar类源码解析
骑个小蜗牛的博客
01-25 1万+
目录调度任务注册器参数任务调度器相关方法各种类型任务相关方法任务执行相关方法其他方法 调度任务注册器参数 public class ScheduledTaskRegistrar implements ScheduledTaskHolder, InitializingBean, DisposableBean { // 任务调度器 private TaskScheduler taskScheduler; // 本地执行器 private ScheduledExecutorService localEx
最简单的java定时任务@Scheduled注解以及定时任务开关
qq_43907515的博客
06-09 6905
1.如何使用@Scheduled注解 2.如何设置定时任务开关
SpringBoot日常：@Scheduled开关控制
qq_32590535的博客
05-22 1757
日常比较小的项目常常使用springboot中的@scheduled注解来完成定时任务。本地和线上dev环境用的是同一套数据源，我们希望所有的定时任务都由线上的去执行，本地不执行，避免数据混乱。那r如何通过配置文件的方式来决定这个定时器的开关状态？我们可以添加一个SchedulingConfig配置文件，利用注解@ConditionalOnProperty来实现根据配置文件参数是否开启定时任务，当配置为true为开启，false则为关闭。
springboot中@scheduled的开关机制（针对单个定时任务）
qq_37826571的博客
03-25 9524
目前遇到的问题： 我们可以在springboot中使用@scheduled注解来完成定时任务。我现在有两台机器部署同一个应用。 一台希望开启这个定时器，另一台希望关闭它。 解决方案： 1. 自己定义一个参数，在定时方法中对其判断。由于我这个方法每分钟执行一次。所以效率不高。 application.properties ： scheduling.enabled=true 业务代码...
【定时任务】---- xxl-job、@Scheduled
m0_46459413的博客
01-09 8017
XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。解压源码,按照maven格式将源码导入IDE, 使用maven进行编译即可，源码结构如下：xxl-job-admin：调度中心xxl-job-core：公共依赖xxl-job-executor-samples：执行器Sample示例（选择合适的版本执行器，可直接使用，也可以参考其并将现有项目改造成执行器）
SpringBoot定时任务卡住了？别再用默认线程池了，手把手教你配置@Scheduled多线程
最新发布
weixin_42548888的博客
04-18 408
本文深入解析SpringBoot中@Scheduled定时任务卡顿问题，揭示默认单线程池的性能瓶颈，并提供三种多线程优化方案：全局ThreadPoolTaskScheduler配置、@Async异步执行及动态线程池调节。通过实战案例和参数调优指南，帮助开发者提升定时任务并发处理能力，有效解决任务阻塞问题。
SpringBoot实现轻量级动态定时任务管控及组件化
kfashfasf的博客
01-21 1194
关于在SpringBoot中使用定时任务，大部分都是直接使用SpringBoot的@Scheduled注解，如下： 或者或者使用第三方的工具，例如XXL-Job等。就XXL-Job而言，如果说是大型项目，硬件资源和项目环境都具备，XXL-Job确实是最佳的选择，可是对于项目体量不大，又不想过多的引入插件；使用XXL-Job多少有点“杀鸡用牛刀”的意思；之所以这样说，是因为在SpringBoot中集成使用XXL-Job的步骤如下：引入依赖，配置执行器Bean在自己项目中编写定时任务代码部署XXL-Job登
SpringBoot Schedule 配置
ＺＥＥＧＡＴＥＳ的博客
12-19 8548
1. 定时任务实现方式 定时任务实现方式： Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，有空介
Spring Boot 中的 @Scheduled 定时任务以及开关控制
不积跬步，无以至千里；不积小流，无以成江海。
12-20 1386
Scheduled注解是Spring框架（包括Spring Boot）中用于实现定时任务的一种方式。
实现Schedule动态开关，以及corn的调节
芒果的日常记录
08-19 3271
因为工作中用到实现后台控制定时器的开关，以及间隔时间的设计，所以在网上总结了一些资料 第一种方法：设计一个数据库表，取出字段，当状态为关的时候，那么就不执行 @Component public class TestScheduling { private static int i = 0; @Scheduled(fixedDelay=5*1000) public void test(){ if(判断状态){ //执行已经关闭 }else{ 执行...
【解决方案】聊一聊动态定时任务之 ScheduledTaskRegistrar 类
weixin_43248862的博客
11-26 2017
在做 SpringBoot 项目的过程中，有时客户会提出按照指定时间执行一次业务的需求。在单一使用 ScheduledTaskRegistrar 类解决定时任务问题的时候，可能会达不到预期的动态调整定时任务的效果。
ScheduledTaskRegistrar实现定时任务
风_z
05-22 858
在spring boot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实现定时任务。要实现动态增删启停定时任务功能，比较广泛的做法是集成Quartz框架。添加实现了CommandLineRunner接口的SysJobRunner类，当spring boot项目启动完成后，加载数据库里状态为正常的定时任务。添加定时任务注册类，用来增加、删除定时任务。修改定时任务，先移除原来的任务，再启动新任务。
Spring Boot 定时任务单线程和多线程
热门推荐
u013456370的专栏
03-01 8万+
Spring Boot 的定时任务： 第一种：把参数配置到.properties文件中： 代码： package com.accord.task; import java.text.SimpleDateFormat; import java.util.Date; import org.springframework.scheduling.annotation.Scheduled; imp
SpringBoot定时任务@Scheduled注解
angang12的博客
07-06 1338
SpringBoot定时任务@Scheduled注解 Spring中的@Scheduled可以进行定时任务开发，定时执行方法。 首先要在执行类加注解@EnableScheduling，具体方法上加@Scheduled import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.Scheduled; import org.springfra
通过配置开关 Spring Boot 中的 @Scheduled 定时任务
码狐
02-05 3189
通过配置开关 Spring Boot 中的 @Scheduled 定时任务 Spring Boot 中提供了一种非常简单的定时任务的实现方式 @Scheduled 注解，只需要加两个注解就可以轻松搞定。 1. 快速上手 @Scheduled 在 Spring Boot 中要想使用 @Scheduled 注解，先要在启动类上加上注解 @EnableScheduling @Configuration @EnableScheduling public class ScheduleConfig { } @Co
SpringBoot中使用@Scheduled实现定时任务通过读取配置文件动态开关
BADAO_LIUMANG_QIZHI的博客
05-25 3490
上面讲的通过@Scheduled注解实现简单定时任务的方式。如果定时任务有多个，不同业务场景下需要动态配置某个定时任务的开关。可以通过@ConditionalOnProperty注解来实现。@ConditionalOnProperty注解来控制@Configuration是否生效。把每个定时定位抽离出到单独一个Task类中，将Task类原来的@Component注解改为@Configuration注解。然后在配置文件中配置对应的定时任务是否执行的表达式，在注解。
@Scheduled注解停止定时任务、@Scheduled设置定时任务不启用、springboot 配置Schedule不启用、SpringBoot动态配置开启关闭定时任务
weixin_49114503的博客
09-24 4706
@Scheduled注解停止定时任务、@Scheduled设置定时任务不启用、springboot 配置Schedule不启用、SpringBoot动态配置开启关闭定时任务
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值