使用Spring编程方式调度任务（动态设置fixedRate）。

Question

使用Spring编程方式调度任务（动态设置fixedRate）。

javaspringscheduled-tasksspring-annotationsspring-scheduled

103

目前我有这个：

@Scheduled(fixedRate=5000)
public void getSchedule(){
   System.out.println("in scheduled job");
}

我可以将此更改为使用对属性的引用

@Scheduled(fixedRateString="${myRate}")
public void getSchedule(){
   System.out.println("in scheduled job");
}

但是我需要使用通过编程获取的值，以便可以在无需重新部署应用程序的情况下更改计划。最好的方法是什么？我意识到可能无法使用注释...

- NimChimpsky

你说“不需要重新部署应用程序”。更改属性引用可以通过应用程序重启而无需重新部署来完成（例如，通过更新系统属性然后重启）。这样是否足够，还是您想要在不重新部署或重启的情况下进行更改？ - M. Justin

8个回答

27

您还可以使用Spring表达式语言（SpEL）来实现此目的。

一旦初始化了这个值，您将无法更新这个值。

@Scheduled(fixedRateString = "#{@applicationPropertyService.getApplicationProperty()}")
public void getSchedule(){
   System.out.println("in scheduled job");
}

@Service
public class ApplicationPropertyService {

    public String getApplicationProperty(){
        //get your value here
        return "5000";
    }
}

- Sagar Ahuja

1

我更喜欢这个选择，因为代码更少、更干净。 - Pemassi

2

您可以通过将Bean作用域设置为RefreshScope以及实现RefreshScopeRefreshedEvent来更改值。示例应用程序在此处 https://github.com/winster/SpringSchedulerDynamic - Winster

我的问题是，如果我们覆盖AppProp.Service类并给出两个不同的延迟时间，调度程序会运行两次吗？ - mfaisalhyder

不会，它将使用被覆盖的属性，如果您想让调度程序运行多次，请使用CRON。 - Sagar Ahuja

如果我们需要动态更改cron值，那么这不起作用。 - Kushwaha

19

为了创建和管理多个动态调度任务，

需要进行调度器配置和Bean设置：

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

@Configuration
@EnableScheduling
public class SchedulingConfigs implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(new Runnable() {
            @Override
            public void run() {
                // Do not put @Scheduled annotation above this method, we don't need it anymore.
                System.out.println("Running Scheduler..." + Calendar.getInstance().getTime());
            }
        }, new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                Calendar nextExecutionTime = new GregorianCalendar();
                Date lastActualExecutionTime = triggerContext.lastActualExecutionTime();
                nextExecutionTime.setTime(lastActualExecutionTime != null ? lastActualExecutionTime : new Date());
                nextExecutionTime.add(Calendar.MILLISECOND, getNewExecutionTime());
                return nextExecutionTime.getTime();
            }
        });
    }

    private int getNewExecutionTime() {
        //Load Your execution time from database or property file
        return 1000;
    }

    @Bean
    public TaskScheduler poolScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("ThreadPoolTaskScheduler");
        scheduler.setPoolSize(1);
        scheduler.initialize();
        return scheduler;
    }
}

调度程序代码：

package io.loadium.resource.service;

import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;

@Service
public class ScheduleTaskService {

    // Task Scheduler
    TaskScheduler scheduler;

    // A map for keeping scheduled tasks
    Map<Integer, ScheduledFuture<?>> jobsMap = new HashMap<>();

    public ScheduleTaskService(TaskScheduler scheduler) {
        this.scheduler = scheduler;
    }


    // Schedule Task to be executed every night at 00 or 12 am
    public void addTaskToScheduler(int id, Runnable task, Date runningDate) {
        ScheduledFuture<?> scheduledTask = scheduler.schedule(task, runningDate);
        jobsMap.put(id, scheduledTask);
    }

    // Remove scheduled task
    public void removeTaskFromScheduler(int id) {
        ScheduledFuture<?> scheduledTask = jobsMap.get(id);
        if (scheduledTask != null) {
            scheduledTask.cancel(true);
            jobsMap.put(id, null);
        }
    }

    // A context refresh event listener
    @EventListener({ContextRefreshedEvent.class})
    void contextRefreshedEvent() {
        // Get all tasks from DB and reschedule them in case of context restarted
    }
}

使用示例：

// Add a new task with runtime after 10 seconds
scheduleTaskService.addTaskToScheduler(1, () -> System.out.println("my task is running -> 1"), , Date.from(LocalDateTime.now().plusSeconds(10).atZone(ZoneId.systemDefault()).toInstant()));
// Remove scheduled task
scheduleTaskService.removeTaskFromScheduler(1);

- Bilal Demir

简而言之：只需自动装配“TaskScheduler scheduler”并使用它。 - Lubo

有可能解释一下吗？我尝试在getNewExecutionTime方法中使用一个随机器，但似乎它并不影响任务启动的时间。 - Maxrunner

10

您可以使用这个简单的方法：

private int refreshTickNumber = 10;
private int tickNumber = 0; 

@Scheduled(fixedDelayString = "${some.rate}")
public void nextStep() {
    if (tickNumber < refreshTickNumber) {
        tickNumber++;
        return;
    }
    else {
        tickNumber = 0;
    }
    // some code
}

refreshTickNumber 可以在运行时完全配置，并可以与 @Value 注释一起使用。

- Praytic

12

不是很有用，引入了太多的额外负担。 - Rade_303

3

其实并不是那么多。 - Praytic

2

如果像我一样，你想要动态地调整// some code在计划任务中实际运行的频率（以some.rate的间隔），那么这个方法是可行的。但它并没有真正回答问题，即如何动态设置fixedRateString的值。使用这种方式，任务仍然会在每个some.rate间隔触发，但只有当Tick Count刷新时，任务中的the business code才会运行。问题和其他答案都是关于调整任务触发时间以直接控制任务中the business code运行时间的权衡。 - geneSummons

9

您可以使用TaskScheduler和ScheduledFuture来管理重新启动调度：

@Configuration
@EnableScheduling
@Component
public class CronConfig implements SchedulingConfigurer , SchedulerObjectInterface{

    @Autowired
    private ScheduledFuture<?> future;

     @Autowired
        private TaskScheduler scheduler;

    @Bean
    public SchedulerController schedulerBean() {
        return new SchedulerController();
    }

    @Bean(destroyMethod = "shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(100);
    } 

        @Override
    public void start() {
        future = scheduler.schedule(new Runnable() {
            @Override
            public void run() {
                //System.out.println(JOB + "  Hello World! " + new Date());
                schedulerBean().schedulerJob();
            }
        }, new Trigger() {
            @Override public Date nextExecutionTime(TriggerContext triggerContext) {
                Calendar nextExecutionTime =  new GregorianCalendar();
                Date lastActualExecutionTime = triggerContext.lastActualExecutionTime(); 
           nextExecutionTime.setTime(convertExpresssiontoDate());//you can get the value from wherever you want
                return nextExecutionTime.getTime();
            }
        });

    }


    @Override
    public void stop() {
        future.cancel(true);

    }

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // TODO Auto-generated method stub
        start();
    }

}

启动停止接口：

public interface SchedulerObjectInterface {    
    void start();
    void stop();
}

现在你可以停止和重新启动（重启）使用@Autowired SchedulerObjectInterface的调度。

- Sandip Solanki

2

这是一个简单的Spring Boot示例，仅限于秒、分钟和小时间隔。该示例旨在演示两个属性TimeUnit和interval的有条件处理。

属性：

snapshot.time-unit=SECONDS
snapshot.interval=5

预定方法：

@Scheduled(cron = "*/1 * * * * *")
protected void customSnapshotScheduler()
{
    LocalDateTime now = LocalDateTime.now();
    TimeUnit timeUnit = TimeUnit.valueOf(snapshotProperties.getSnapshot().getTimeUnit());
    int interval = snapshotProperties.getSnapshot().getInterval();

    if (TimeUnit.SECONDS == timeUnit
            && now.getSecond() % interval == 0)
    {
        this.camService.writeSnapshot(webcam.getImage());
    }

    if (TimeUnit.MINUTES == timeUnit
            && now.getMinute() % interval == 0)
    {
        this.camService.writeSnapshot(webcam.getImage());
    }

    if (TimeUnit.HOURS == timeUnit
            && now.getHour() % interval == 0)
    {
        this.camService.writeSnapshot(webcam.getImage());
    }
}

- mmamane

1

在MySchedularService类中，我们看到了如何调用"#{@getIntervalTime}"并从@Bean注释类中获取下一次计划调用的时间间隔。

主类

package com;

import java.util.Calendar;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class SbootSchedularApplication {

    public static void main(String[] args) {
        SpringApplication.run(SbootSchedularApplication.class, args);
    }
    
    @Value("${schedular3Timing}")
    String schedular3Timing;
    
    @Bean
    public String getIntervalTime() 
    {
        long startSchedulerAfterMiliSec = setSchedule(schedular3Timing);

        return ""+startSchedulerAfterMiliSec;
    }
    
    public long setSchedule(String key) 
    {
        int hour = Integer.parseInt(key.substring(0, key.indexOf(":")));
        int min = Integer.parseInt(key.substring(key.indexOf(":") + 1));

        Calendar schedulerCal = Calendar.getInstance();
        schedulerCal.set(Calendar.HOUR, hour);
        schedulerCal.set(Calendar.MINUTE, min);
        schedulerCal.set(Calendar.SECOND, 0);
        
        Calendar localCal = Calendar.getInstance();
        Long currentTimeInMilliSec = localCal.getTime().getTime();
        String currentDayTime = localCal.getTime().toString();

        if (schedulerCal.getTime().getTime() < currentTimeInMilliSec) {         // Means calculating time reference from time 00:00, if current time is 1000 mili-sec and scheduled time is 800 mili-sec -> then that time is already happened, so better add one more day in that same timing.
            schedulerCal.add(Calendar.DATE, 1);         // add 1 day more in the Schedular, if scheduled-MiliSec is less than the current-MiliSec.
        }

        long scheduledTimeInMilliSec = schedulerCal.getTime().getTime();
        String scheduledTime = schedulerCal.getTime().toString();
        System.out.println("** Scheduled start time for the task    : " + scheduledTime + " *** " + scheduledTimeInMilliSec);
        System.out.println("** Current time of the day      : " + currentDayTime + " *** " + currentTimeInMilliSec);

        long startScheduler = scheduledTimeInMilliSec - currentTimeInMilliSec;      // eg: scheduledTime(5pm) - currentTime(3pm) = (2hr)startSchedulerAfter
        return startScheduler;

    }

}

MySchedularService类：查看JOB-3

package com.service;

import java.util.Date;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class MySchedularService {

    private static final Logger logger = LoggerFactory.getLogger(MySchedularService.class);

//  @Scheduled(fixedRate = 2000, initialDelay = 5000L)
    @Scheduled(fixedRateString = "${schedular1.fixedRateInMS}", initialDelay = 1000L)
    public void job() {
        logger.info("Job1 Run Time : " + new Date());
    }
    
//  @Scheduled(fixedRateString = "${schedular2.fixedRateInMS}", initialDelay = 5000L)
//  public void job2() {
//      logger.info("Job2 Run Time : " + new Date());
//  }

    @Scheduled(fixedRate = 10000 , initialDelayString = "#{@getIntervalTime}")      // we can change the fixedRate = 86400000L miliseconds (i.e, one day interval)    
    public void job3() {
        logger.info("**Job2 Run Time : " + new Date());
    }
    
    

}

Application.properties 文件

spring.task.scheduling.pool.size=10
schedular1.fixedRateInMS=3000
schedular2.fixedRateInMS=10000
schedular3Timing=01:07

- Rahul Sinha Rj

0

我使用org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler中的ThreadPoolTaskScheduler创建了动态任务，并使用scheduleWithFixedDelay方法进行调度。为了防止分布式环境中的重复作业，我还添加了Redisson锁。以下是我的代码：

public class TaskRunnerService {

    private final ThreadPoolTaskScheduler taskScheduler;
    private final RedissonClient redissonClient;


    public TaskRunnerService(ThreadPoolTaskScheduler taskScheduler, RedissonClient redissonClient) {
        this.taskScheduler = taskScheduler;
        this.redissonClient = redissonClient;
    }

    @PostConstruct
    public void runTasks() {
        List<TaskDTO> taskDTOS = TaskHolder.createTasks();
        for (TaskDTO taskDTO : taskDTOS) {
            RLock lock = this.redissonClient.getFairLock("LoadAndRunScheduleService-" + taskDTO.getId());

            if (lock.tryLock()) {
                try {
                    this.taskScheduler.scheduleWithFixedDelay(() -> {
                        System.out.println(" running task " + taskDTO.getId() + " with delay " + taskDTO.getDelay() + " at " + new Date());
                    }, taskDTO.getDelay() * 1000L);
                }finally {
                    lock.unlock();
                }
            }
        }
    }

}

我创建了一个 TaskDTO 类，以便能够在运行时获取延迟：

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

    @AllArgsConstructor
    @NoArgsConstructor
    @Getter
    @Setter
    public class TaskDTO {
    
        private int id;
        private int delay;
    }

配置类是：

    @Configuration
    public class AppConfig {
    
        @Bean
        ThreadPoolTaskScheduler taskScheduler(){
            ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
            scheduler.setThreadNamePrefix("ThreadPoolTaskScheduler");
            scheduler.setPoolSize(2);
            scheduler.initialize();
            return scheduler;
        }
    
    }

- saba

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- ach · Accepted Answer

使用Trigger，您可以即时计算下一次的执行时间。

类似这样的代码应该可以实现（改编自@EnableScheduling的Javadoc文档）：

@Configuration
@EnableScheduling
public class MyAppConfig implements SchedulingConfigurer {

    @Autowired
    Environment env;

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }

    @Bean(destroyMethod = "shutdown")
    public Executor taskExecutor() {
        return Executors.newScheduledThreadPool(100);
    }

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());
        taskRegistrar.addTriggerTask(
                new Runnable() {
                    @Override public void run() {
                        myBean().getSchedule();
                    }
                },
                new Trigger() {
                    @Override public Date nextExecutionTime(TriggerContext triggerContext) {
                        Calendar nextExecutionTime =  new GregorianCalendar();
                        Date lastActualExecutionTime = triggerContext.lastActualExecutionTime();
                        nextExecutionTime.setTime(lastActualExecutionTime != null ? lastActualExecutionTime : new Date());
                        nextExecutionTime.add(Calendar.MILLISECOND, env.getProperty("myRate", Integer.class)); //you can get the value from wherever you want
                        return nextExecutionTime.getTime();
                    }
                }
        );
    }
}